# HG changeset patch
# User haftmann
# Date 1330810661 -3600
# Node ID 3d3d8f8929a7f7740f4432bd0ca5e4a063ad0490
# Parent  f0285e69d70497c870a673899cd0602e88dd22aa
file system structure separating HOL4 and HOL Light concerns

diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/Generate-HOL/GenHOL4Base.thy
--- a/src/HOL/Import/Generate-HOL/GenHOL4Base.thy	Sat Mar 03 21:51:38 2012 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,279 +0,0 @@
-(*  Title:      HOL/Import/Generate-HOL/GenHOL4Base.thy
-    Author:     Sebastian Skalberg, TU Muenchen
-*)
-
-theory GenHOL4Base imports "../HOL4Compat" "../HOL4Syntax" begin;
-
-import_segment "hol4";
-
-setup_dump "../HOL" "HOL4Base";
-
-append_dump {*theory HOL4Base imports "../HOL4Compat" "../HOL4Syntax" begin*};
-
-import_theory "~~/src/HOL/Import/HOL" 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         > HOL4Setup.ONE_ONE
-  ONTO            > Fun.surj
-  TYPE_DEFINITION > HOL4Setup.TYPE_DEFINITION
-  LET             > HOL4Compat.LET;
-
-ignore_thms
-  BOUNDED_DEF
-  BOUNDED_THM
-  UNBOUNDED_DEF
-  UNBOUNDED_THM;
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" combin;
-
-const_maps
-  o > Fun.comp;
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" sum;
-
-type_maps
-  sum > Sum_Type.sum;
-
-const_maps
-  INL      > Sum_Type.Inl
-  INR      > Sum_Type.Inr
-  ISL      > HOL4Compat.ISL
-  ISR      > HOL4Compat.ISR
-  OUTL     > HOL4Compat.OUTL
-  OUTR     > HOL4Compat.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/HOL" 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/HOL" 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     > HOL4Compat.IS_SOME
-    IS_NONE     > HOL4Compat.IS_NONE
-    OPTION_JOIN > HOL4Compat.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/HOL" marker;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" relation;
-
-const_renames
-  reflexive > pred_reflexive;
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" 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/HOL" 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/HOL" prim_rec;
-
-const_maps
-    "<" > Orderings.ord_class.less :: "nat \<Rightarrow> nat \<Rightarrow> bool";
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" arithmetic;
-
-const_maps
-  ALT_ZERO     > HOL4Compat.ALT_ZERO
-  NUMERAL_BIT1 > HOL4Compat.NUMERAL_BIT1
-  NUMERAL_BIT2 > HOL4Compat.NUMERAL_BIT2
-  NUMERAL      > HOL4Compat.NUMERAL
-  num_case     > Nat.nat.nat_case
-  ">"          > HOL4Compat.nat_gt
-  ">="         > HOL4Compat.nat_ge
-  FUNPOW       > HOL4Compat.FUNPOW
-  "<="         > Orderings.ord_class.less_eq :: "nat \<Rightarrow> nat \<Rightarrow> bool"
-  "+"          > Groups.plus_class.plus :: "nat \<Rightarrow> nat \<Rightarrow> nat"
-  "*"          > Groups.times_class.times :: "nat \<Rightarrow> nat \<Rightarrow> nat"
-  "-"          > Groups.minus_class.minus :: "nat \<Rightarrow> nat \<Rightarrow> nat"
-  MIN          > Orderings.ord_class.min :: "nat \<Rightarrow> nat \<Rightarrow> nat"
-  MAX          > Orderings.ord_class.max :: "nat \<Rightarrow> nat \<Rightarrow> nat"
-  DIV          > Divides.div_class.div :: "nat \<Rightarrow> nat \<Rightarrow> nat"
-  MOD          > Divides.div_class.mod :: "nat \<Rightarrow> nat \<Rightarrow> nat"
-  EXP          > Power.power_class.power :: "nat \<Rightarrow> nat \<Rightarrow> nat";
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" hrat;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" hreal;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" numeral;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" ind_type;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" divides;
-
-const_maps
-  divides > Rings.dvd_class.dvd :: "nat \<Rightarrow> nat \<Rightarrow> bool";
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" prime;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" 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       > HOL4Compat.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 > HOL4Compat.list_size
-  SUM       > HOL4Compat.sum
-  FOLDR     > HOL4Compat.FOLDR
-  EXISTS    > List.list_ex
-  MAP2      > HOL4Compat.map2
-  ZIP       > HOL4Compat.ZIP
-  UNZIP     > HOL4Compat.unzip;
-
-ignore_thms
-  list_TY_DEF
-  list_repfns
-  list0_def
-  list1_def
-  NIL
-  CONS_def;
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" pred_set;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" operator;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" rich_list;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" state_transformer;
-end_import;
-
-append_dump "end";
-
-flush_dump;
-
-import_segment "";
-
-end
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/Generate-HOL/GenHOL4Prob.thy
--- a/src/HOL/Import/Generate-HOL/GenHOL4Prob.thy	Sat Mar 03 21:51:38 2012 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,47 +0,0 @@
-(*  Title:      HOL/Import/Generate-HOL/GenHOL4Prob.thy
-    Author:     Sebastian Skalberg, TU Muenchen
-*)
-
-theory GenHOL4Prob imports GenHOL4Real begin
-
-import_segment "hol4";
-
-setup_dump "../HOL" "HOL4Prob";
-
-append_dump "theory HOL4Prob imports HOL4Real begin";
-
-import_theory "~~/src/HOL/Import/HOL" prob_extra;
-
-const_moves
-  COMPL > GenHOL4Base.pred_set.COMPL;
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" prob_canon;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" boolean_sequence;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" prob_algebra;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" prob;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" prob_pseudo;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" prob_indep;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" prob_uniform;
-end_import;
-
-append_dump "end";
-
-flush_dump;
-
-import_segment "";
-
-end
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/Generate-HOL/GenHOL4Real.thy
--- a/src/HOL/Import/Generate-HOL/GenHOL4Real.thy	Sat Mar 03 21:51:38 2012 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,96 +0,0 @@
-(*  Title:      HOL/Import/Generate-HOL/GenHOL4Real.thy
-    Author:     Sebastian Skalberg (TU Muenchen)
-*)
-
-theory GenHOL4Real imports GenHOL4Base begin
-
-import_segment "hol4";
-
-setup_dump "../HOL" "HOL4Real";
-
-append_dump "theory HOL4Real imports HOL4Base begin";
-
-import_theory "~~/src/HOL/Import/HOL" realax;
-
-type_maps
-  real > RealDef.real;
-
-const_maps
-  real_0   > Groups.zero_class.zero :: real
-  real_1   > Groups.one_class.one   :: real
-  real_neg > Groups.uminus_class.uminus :: "real \<Rightarrow> real"
-  inv > Fields.inverse_class.inverse :: "real \<Rightarrow> real"
-  real_add > Groups.plus_class.plus :: "real \<Rightarrow> real \<Rightarrow> real"
-  real_sub > Groups.minus_class.minus :: "real \<Rightarrow> real \<Rightarrow> real"
-  real_mul > Groups.times_class.times :: "real \<Rightarrow> real \<Rightarrow> real"
-  real_div > Fields.inverse_class.divide :: "real \<Rightarrow> real \<Rightarrow> real"
-  real_lt > Orderings.ord_class.less :: "real \<Rightarrow> real \<Rightarrow> bool"
-  mk_real > HOL.undefined   (* Otherwise proof_import_concl fails *)
-  dest_real > HOL.undefined
-
-ignore_thms
-    real_TY_DEF
-    real_tybij
-    real_0
-    real_1
-    real_neg
-    real_inv
-    real_add
-    real_mul
-    real_lt
-    real_of_hreal
-    hreal_of_real
-    REAL_ISO_EQ
-    REAL_POS
-    SUP_ALLPOS_LEMMA1
-    SUP_ALLPOS_LEMMA2
-    SUP_ALLPOS_LEMMA3
-    SUP_ALLPOS_LEMMA4;
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" real;
-
-const_maps
-  real_gt     > HOL4Compat.real_gt
-  real_ge     > HOL4Compat.real_ge
-  real_lte    > Orderings.ord_class.less_eq :: "real \<Rightarrow> real \<Rightarrow> bool"
-  real_sub    > Groups.minus_class.minus :: "real \<Rightarrow> real \<Rightarrow> real"
-  "/"         > Fields.inverse_class.divide :: "real \<Rightarrow> real \<Rightarrow> real"
-  pow         > Power.power_class.power :: "real \<Rightarrow> nat \<Rightarrow> real"
-  abs         > Groups.abs_class.abs :: "real => real"
-  real_of_num > RealDef.real :: "nat => real";
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" topology;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" nets;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" seq;
-const_renames
-"-->" > "hol4-->";
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" lim;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" powser;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" transc;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" poly;
-end_import;
-
-append_dump "end";
-
-flush_dump;
-
-import_segment "";
-
-end
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/Generate-HOL/GenHOL4Vec.thy
--- a/src/HOL/Import/Generate-HOL/GenHOL4Vec.thy	Sat Mar 03 21:51:38 2012 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,44 +0,0 @@
-(*  Title:      HOL/Import/Generate-HOL/GenHOL4Vec.thy
-    Author:     Sebastian Skalberg, TU Muenchen
-*)
-
-theory GenHOL4Vec imports GenHOL4Base begin
-
-import_segment "hol4";
-
-setup_dump "../HOL" "HOL4Vec";
-
-append_dump "theory HOL4Vec imports HOL4Base begin";
-
-import_theory "~~/src/HOL/Import/HOL" res_quan;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" word_base;
-
-const_renames
-  BIT > bit;
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" word_num;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" word_bitop;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" bword_num;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" bword_arith;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" bword_bitop;
-end_import;
-
-append_dump "end";
-
-flush_dump;
-
-import_segment "";
-
-end
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/Generate-HOL/GenHOL4Word32.thy
--- a/src/HOL/Import/Generate-HOL/GenHOL4Word32.thy	Sat Mar 03 21:51:38 2012 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,33 +0,0 @@
-(*  Title:      HOL/Import/Generate-HOL/GenHOL4Word32.thy
-    Author:     Sebastian Skalberg, TU Muenchen
-*)
-
-theory GenHOL4Word32 imports GenHOL4Base begin;
-
-import_segment "hol4";
-
-setup_dump "../HOL" "HOL4Word32";
-
-append_dump "theory HOL4Word32 imports HOL4Base begin";
-
-import_theory "~~/src/HOL/Import/HOL" bits;
-
-const_renames
-  BIT > bit
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL" word32;
-
-const_renames
-  "==" > EQUIV;
-
-end_import;
-
-append_dump "end";
-
-flush_dump;
-
-import_segment "";
-
-end
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/Generate-HOL/ROOT.ML
--- a/src/HOL/Import/Generate-HOL/ROOT.ML	Sat Mar 03 21:51:38 2012 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,3 +0,0 @@
-use_thy "GenHOL4Prob";
-use_thy "GenHOL4Vec";
-use_thy "GenHOL4Word32";
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/Generate-HOLLight/GenHOLLight.thy
--- a/src/HOL/Import/Generate-HOLLight/GenHOLLight.thy	Sat Mar 03 21:51:38 2012 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,215 +0,0 @@
-(*  Title:      HOL/Import/Generate-HOLLight/GenHOLLight.thy
-    Author:     Steven Obua, TU Muenchen
-    Author:     Cezary Kaliszyk
-*)
-
-theory GenHOLLight imports "../HOLLightCompat" "../HOL4Syntax" begin
-
-;import_segment "hollight"
-
-;setup_dump "../HOLLight" "HOLLight";
-
-;append_dump {*theory HOLLight imports "../HOLLightCompat" "../HOL4Syntax" begin *}
-
-import_theory "~~/src/HOL/Import/HOLLight" hollight
-
-;ignore_thms
-  (* Unit type *)
-  TYDEF_1 DEF_one
-  (* Product type *)
-  TYDEF_prod "DEF_," DEF_mk_pair REP_ABS_PAIR
-  (* Option type *)
-  TYDEF_option DEF_NONE DEF_SOME
-  (* Sum type *)
-  TYDEF_sum DEF_INL DEF_INR DEF_OUTL DEF_OUTR
-  (* Naturals *)
-  TYDEF_num DEF__0 DEF_SUC
-  (* Lists *)
-  TYDEF_list DEF_NIL DEF_CONS DEF_HD DEF_TL DEF_MAP2 DEF_ITLIST2 ALL_MAP EX_MAP
-  DEF_ASSOC MEM_ASSOC DEF_ZIP EL_TL
-
-  (* list_of_set uses Isabelle lists with HOLLight CARD *)
-  DEF_list_of_set LIST_OF_SET_PROPERTIES SET_OF_LIST_OF_SET LENGTH_LIST_OF_SET
-  MEM_LIST_OF_SET HAS_SIZE_SET_OF_LIST FINITE_SET_OF_LIST
-  (* UNIV *)
-  DIMINDEX_FINITE_SUM  DIMINDEX_HAS_SIZE_FINITE_SUM FSTCART_PASTECART
-  SNDCART_PASTECART PASTECART_FST_SND PASTECART_EQ FORALL_PASTECART EXISTS_PASTECART
-  (* Reals *)
-  (* TYDEF_real DEF_real_of_num DEF_real_neg DEF_real_add DEF_real_mul DEF_real_le
-  DEF_real_inv REAL_HREAL_LEMMA1 REAL_HREAL_LEMMA2 *)
-  (* Integers *)
-  (* TYDEF_int DEF_int_divides DEF_int_coprime*)
-  (* HOLLight CARD and CASEWISE with Isabelle lists *)
-  CARD_SET_OF_LIST_LE CASEWISE CASEWISE_CASES RECURSION_CASEWISE CASEWISE_WORKS
-  WF_REC_CASES RECURSION_CASEWISE_PAIRWISE
-
-;type_maps
-  bool > HOL.bool
-  "fun" > "fun"
-  N_1 >  Product_Type.unit
-  prod > Product_Type.prod
-  ind > Nat.ind
-  num > Nat.nat
-  sum > Sum_Type.sum
-  option > Datatype.option
-  list > List.list
-(*real > RealDef.real *)
-(*int > Int.int *)
-
-;const_renames
-  "==" > "eqeq"
-  "ALL" > list_ALL
-  "EX" > list_EX
-
-;const_maps
-  T > HOL.True
-  F > HOL.False
-  "=" > HOL.eq
-  "==>" > HOL.implies
-  "/\\" > HOL.conj
-  "\\/" > HOL.disj
-  "!" > HOL.All
-  "?" > HOL.Ex
-  "?!" > HOL.Ex1
-  "~" > HOL.Not
-  COND > HOL.If
-  ONE_ONE > Fun.inj
-  ONTO > Fun.surj
-  o > Fun.comp
-  "@" > Hilbert_Choice.Eps
-  CHOICE > Hilbert_Choice.Eps
-  I > Fun.id
-  one > Product_Type.Unity
-  LET > HOLLightCompat.LET
-  mk_pair > Product_Type.Pair_Rep
-  "," > Product_Type.Pair
-  FST > Product_Type.fst
-  SND > Product_Type.snd
-  CURRY > Product_Type.curry
-  "_0" > Groups.zero_class.zero :: nat
-  SUC > Nat.Suc
-  PRE > HOLLightCompat.Pred
-  NUMERAL > HOLLightCompat.NUMERAL
-  mk_num > Fun.id
-  "+" > Groups.plus_class.plus :: "nat \<Rightarrow> nat \<Rightarrow> nat"
-  "*" > Groups.times_class.times :: "nat \<Rightarrow> nat \<Rightarrow> nat"
-  "-" > Groups.minus_class.minus :: "nat \<Rightarrow> nat \<Rightarrow> nat"
-  "<" > Orderings.ord_class.less :: "nat \<Rightarrow> nat \<Rightarrow> bool"
-  "<=" > Orderings.ord_class.less_eq :: "nat \<Rightarrow> nat \<Rightarrow> bool"
-  ">" > Orderings.ord_class.greater :: "nat \<Rightarrow> nat \<Rightarrow> bool"
-  ">=" > Orderings.ord_class.greater_eq :: "nat \<Rightarrow> nat \<Rightarrow> bool"
-  EXP > Power.power_class.power :: "nat \<Rightarrow> nat \<Rightarrow> nat"
-  MAX > Orderings.ord_class.max :: "nat \<Rightarrow> nat \<Rightarrow> nat"
-  MIN > Orderings.ord_class.min :: "nat \<Rightarrow> nat \<Rightarrow> nat"
-  DIV > Divides.div_class.div :: "nat \<Rightarrow> nat \<Rightarrow> nat"
-  MOD > Divides.div_class.mod :: "nat \<Rightarrow> nat \<Rightarrow> nat"
-  BIT0 > HOLLightCompat.NUMERAL_BIT0
-  BIT1 > HOLLightCompat.NUMERAL_BIT1
-  INL > Sum_Type.Inl
-  INR > Sum_Type.Inr
-  OUTL > HOLLightCompat.OUTL
-  OUTR > HOLLightCompat.OUTR
-  NONE > Datatype.None
-  SOME > Datatype.Some
-  EVEN > Parity.even_odd_class.even :: "nat \<Rightarrow> bool"
-  ODD > HOLLightCompat.ODD
-  FACT > Fact.fact_class.fact :: "nat \<Rightarrow> nat"
-  WF > Wellfounded.wfP
-  NIL > List.list.Nil
-  CONS > List.list.Cons
-  APPEND > List.append
-  REVERSE > List.rev
-  LENGTH > List.length
-  MAP > List.map
-  LAST > List.last
-  BUTLAST > List.butlast
-  REPLICATE > List.replicate
-  ITLIST > List.foldr
-  list_ALL > List.list_all
-  ALL2 > List.list_all2
-  list_EX > List.list_ex
-  FILTER > List.filter
-  NULL > List.null
-  HD > List.hd
-  TL > List.tl
-  EL > HOLLightList.list_el
-  ZIP > List.zip
-  MAP2 > HOLLightList.map2
-  ITLIST2 > HOLLightList.fold2
-  MEM > HOLLightList.list_mem
-  set_of_list > List.set
-  IN > Set.member
-  INSERT > Set.insert
-  EMPTY > Orderings.bot_class.bot :: "'a \<Rightarrow> bool"
-  GABS > Hilbert_Choice.Eps
-  GEQ > HOL.eq
-  GSPEC > Set.Collect
-  SETSPEC > HOLLightCompat.SETSPEC
-  UNION > Lattices.sup_class.sup :: "('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> 'a \<Rightarrow> bool"
-  UNIONS > Complete_Lattices.Sup_class.Sup :: "(('a \<Rightarrow> bool) \<Rightarrow> bool) \<Rightarrow> 'a \<Rightarrow> bool"
-  INTER > Lattices.inf_class.inf :: "('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> 'a \<Rightarrow> bool"
-  INTERS > Complete_Lattices.Inf_class.Inf :: "(('a \<Rightarrow> bool) \<Rightarrow> bool) \<Rightarrow> 'a \<Rightarrow> bool"
-  DIFF > Groups.minus_class.minus :: "('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> 'a \<Rightarrow> bool"
-  SUBSET > Orderings.ord_class.less_eq :: "('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> bool"
-  PSUBSET > Orderings.ord_class.less :: "('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> bool"
-  DELETE > HOLLightCompat.DELETE
-  DISJOINT > HOLLightCompat.DISJOINT
-  IMAGE > Set.image
-  FINITE > Finite_Set.finite
-  INFINITE > HOLLightCompat.INFINITE
-  ".." > HOLLightCompat.dotdot
-  UNIV > Orderings.top_class.top :: "'a \<Rightarrow> bool"
-  MEASURE > HOLLightCompat.MEASURE
-(*real_of_num > RealDef.real :: "nat => real"
-  real_neg > Groups.uminus_class.uminus :: "real => 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 \<Rightarrow> real \<Rightarrow> bool"
-  real_le > Orderings.ord_class.less_eq :: "real \<Rightarrow> real \<Rightarrow> bool"
-  real_gt > Orderings.ord_class.greater :: "real \<Rightarrow> real \<Rightarrow> bool"
-  real_ge > Orderings.ord_class.greater_eq :: "real \<Rightarrow> real \<Rightarrow> bool"
-  real_pow > Power.power_class.power :: "real \<Rightarrow> nat \<Rightarrow> real"
-  real_abs > Groups.abs_class.abs :: "real \<Rightarrow> real"
-  real_max > Orderings.ord_class.max :: "real \<Rightarrow> real \<Rightarrow> real"
-  real_min > Orderings.ord_class.min :: "real \<Rightarrow> real \<Rightarrow> real"
-  real_sgn > Groups.sgn_class.sgn :: "real \<Rightarrow> real"*)
-(*real_of_int > RealDef.real :: "int => real"
-  int_of_real > Archimedean_Field.floor :: "real \<Rightarrow> int"
-  dest_int > RealDef.real :: "int => real"
-  mk_int > Archimedean_Field.floor :: "real \<Rightarrow> int"
-  int_lt > Orderings.ord_class.less :: "int \<Rightarrow> int \<Rightarrow> bool"
-  int_le > Orderings.ord_class.less_eq :: "int \<Rightarrow> int \<Rightarrow> bool"
-  int_gt > Orderings.ord_class.greater :: "int \<Rightarrow> int \<Rightarrow> bool"
-  int_ge > Orderings.ord_class.greater_eq :: "int \<Rightarrow> int \<Rightarrow> bool"
-  int_of_num > Nat.semiring_1_class.of_nat :: "nat \<Rightarrow> int"
-  int_neg > Groups.uminus_class.uminus :: "int \<Rightarrow> int"
-  int_add > Groups.plus_class.plus :: "int => int => int"
-  int_sub > Groups.minus_class.minus :: "int => int => int"
-  int_mul > Groups.times_class.times :: "int => int => int"
-  int_abs > Groups.abs_class.abs :: "int \<Rightarrow> int"
-  int_max > Orderings.ord_class.max :: "int \<Rightarrow> int \<Rightarrow> int"
-  int_min > Orderings.ord_class.min :: "int \<Rightarrow> int \<Rightarrow> int"
-  int_sgn > Groups.sgn_class.sgn :: "int \<Rightarrow> int"
-  int_pow > Power.power_class.power :: "int \<Rightarrow> nat \<Rightarrow> int"
-  int_div > HOLLightInt.hl_div :: "int \<Rightarrow> int \<Rightarrow> int"
-  div > HOLLightInt.hl_div :: "int \<Rightarrow> int \<Rightarrow> int"
-  mod_int > HOLLightInt.hl_mod :: "int \<Rightarrow> int \<Rightarrow> int"
-  rem > HOLLightInt.hl_mod :: "int \<Rightarrow> int \<Rightarrow> int"
-  int_divides > Rings.dvd_class.dvd :: "int \<Rightarrow> int \<Rightarrow> bool"
-  int_mod > HOLLightInt.int_mod :: "int \<Rightarrow> int \<Rightarrow> int \<Rightarrow> bool"
-  int_gcd > HOLLightInt.int_gcd :: "int \<times> int \<Rightarrow> int"
-  int_coprime > HOLLightInt.int_coprime :: "int \<times> int \<Rightarrow> bool"
-  eqeq > HOLLightInt.eqeq*)
-
-;end_import
-
-;append_dump "end"
-
-;flush_dump
-
-;import_segment ""
-
-end
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/Generate-HOLLight/ROOT.ML
--- a/src/HOL/Import/Generate-HOLLight/ROOT.ML	Sat Mar 03 21:51:38 2012 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1 +0,0 @@
-use_thy "GenHOLLight";
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/HOL4.thy
--- a/src/HOL/Import/HOL/HOL4.thy	Sat Mar 03 21:51:38 2012 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,10 +0,0 @@
-(*  Title:      HOL/Import/HOL/HOL4.thy
-    Author:     Sebastian Skalberg, TU Muenchen
-*)
-
-theory HOL4
-imports HOL4Vec HOL4Word32 HOL4Real
-begin
-
-end
-
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/HOL4Base.thy
--- a/src/HOL/Import/HOL/HOL4Base.thy	Sat Mar 03 21:51:38 2012 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,4499 +0,0 @@
-(* AUTOMATICALLY GENERATED, DO NOT EDIT! *)
-
-theory HOL4Base imports "../HOL4Compat" "../HOL4Syntax" begin
-
-setup_theory "~~/src/HOL/Import/HOL" 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/HOL" 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/HOL" 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/HOL" one
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL" 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/HOL" 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/HOL" 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/HOL" 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/HOL" num
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL" prim_rec
-
-lemma LESS_0_0: "0 < Suc 0"
-  sorry
-
-lemma LESS_LEMMA1: "x < Suc xa ==> x = xa | x < xa"
-  sorry
-
-lemma LESS_LEMMA2: "m = n | m < n ==> m < Suc n"
-  sorry
-
-lemma LESS_THM: "(m < Suc n) = (m = n | m < n)"
-  sorry
-
-lemma LESS_SUC_IMP: "[| x < Suc xa; x ~= xa |] ==> x < xa"
-  sorry
-
-lemma EQ_LESS: "Suc m = n ==> m < n"
-  sorry
-
-lemma NOT_LESS_EQ: "(m::nat) = (n::nat) ==> ~ m < n"
-  sorry
-
-definition
-  SIMP_REC_REL :: "(nat => 'a) => 'a => ('a => 'a) => nat => bool"  where
-  "SIMP_REC_REL == %fun x f n. fun 0 = x & (ALL m<n. fun (Suc m) = f (fun m))"
-
-lemma SIMP_REC_REL: "SIMP_REC_REL fun x f n = (fun 0 = x & (ALL m<n. fun (Suc m) = f (fun m)))"
-  sorry
-
-lemma SIMP_REC_EXISTS: "EX fun. SIMP_REC_REL fun x f n"
-  sorry
-
-lemma SIMP_REC_REL_UNIQUE: "[| SIMP_REC_REL xb x xa xd & SIMP_REC_REL xc x xa xe; n < xd & n < xe |]
-==> xb n = xc n"
-  sorry
-
-lemma SIMP_REC_REL_UNIQUE_RESULT: "EX! y. EX g. SIMP_REC_REL g x f (Suc n) & y = g n"
-  sorry
-
-consts
-  SIMP_REC :: "'a => ('a => 'a) => nat => 'a" 
-
-specification (SIMP_REC) SIMP_REC: "ALL x f' n. EX g. SIMP_REC_REL g x f' (Suc n) & SIMP_REC x f' n = g n"
-  sorry
-
-lemma LESS_SUC_SUC: "m < Suc m & m < Suc (Suc m)"
-  sorry
-
-lemma SIMP_REC_THM: "SIMP_REC x f 0 = x & (ALL m. SIMP_REC x f (Suc m) = f (SIMP_REC x f m))"
-  sorry
-
-definition
-  PRE :: "nat => nat"  where
-  "PRE == %m. if m = 0 then 0 else SOME n. m = Suc n"
-
-lemma PRE_DEF: "PRE m = (if m = 0 then 0 else SOME n. m = Suc n)"
-  sorry
-
-lemma PRE: "PRE 0 = 0 & (ALL m. PRE (Suc m) = m)"
-  sorry
-
-definition
-  PRIM_REC_FUN :: "'a => ('a => nat => 'a) => nat => nat => 'a"  where
-  "PRIM_REC_FUN == %x f. SIMP_REC (%n. x) (%fun n. f (fun (PRE n)) n)"
-
-lemma PRIM_REC_FUN: "PRIM_REC_FUN x f = SIMP_REC (%n. x) (%fun n. f (fun (PRE n)) n)"
-  sorry
-
-lemma PRIM_REC_EQN: "(ALL n. PRIM_REC_FUN x f 0 n = x) &
-(ALL m n. PRIM_REC_FUN x f (Suc m) n = f (PRIM_REC_FUN x f m (PRE n)) n)"
-  sorry
-
-definition
-  PRIM_REC :: "'a => ('a => nat => 'a) => nat => 'a"  where
-  "PRIM_REC == %x f m. PRIM_REC_FUN x f m (PRE m)"
-
-lemma PRIM_REC: "PRIM_REC x f m = PRIM_REC_FUN x f m (PRE m)"
-  sorry
-
-lemma PRIM_REC_THM: "PRIM_REC x f 0 = x & (ALL m. PRIM_REC x f (Suc m) = f (PRIM_REC x f m) m)"
-  sorry
-
-lemma DC: "P a & (ALL x. P x --> (EX y. P y & R x y))
-==> EX x. x 0 = a & (ALL n. P (x n) & R (x n) (x (Suc n)))"
-  sorry
-
-lemma num_Axiom_old: "EX! fn1. fn1 0 = e & (ALL n. fn1 (Suc n) = f (fn1 n) n)"
-  sorry
-
-lemma num_Axiom: "EX x. x 0 = e & (ALL n. x (Suc n) = f n (x n))"
-  sorry
-
-consts
-  wellfounded :: "('a => 'a => bool) => bool" 
-
-defs
-  wellfounded_primdef: "wellfounded == %R. ~ (EX f. ALL n. R (f (Suc n)) (f n))"
-
-lemma wellfounded_def: "wellfounded R = (~ (EX f. ALL n. R (f (Suc n)) (f n)))"
-  sorry
-
-lemma WF_IFF_WELLFOUNDED: "WF R = wellfounded R"
-  sorry
-
-lemma WF_PRED: "WF (%x y. y = Suc x)"
-  sorry
-
-lemma WF_LESS: "(WF::(nat => nat => bool) => bool) (op <::nat => nat => bool)"
-  sorry
-
-consts
-  measure :: "('a => nat) => 'a => 'a => bool" 
-
-defs
-  measure_primdef: "prim_rec.measure == relation.inv_image op <"
-
-lemma measure_def: "prim_rec.measure = relation.inv_image op <"
-  sorry
-
-lemma WF_measure: "WF (prim_rec.measure x)"
-  sorry
-
-lemma measure_thm: "prim_rec.measure x xa xb = (x xa < x xb)"
-  sorry
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL" arithmetic
-
-definition
-  nat_elim__magic :: "nat => nat"  where
-  "nat_elim__magic == %n. n"
-
-lemma nat_elim__magic: "nat_elim__magic n = n"
-  sorry
-
-consts
-  EVEN :: "nat => bool" 
-
-specification (EVEN) EVEN: "EVEN 0 = True & (ALL n. EVEN (Suc n) = (~ EVEN n))"
-  sorry
-
-consts
-  ODD :: "nat => bool" 
-
-specification (ODD) ODD: "ODD 0 = False & (ALL n. ODD (Suc n) = (~ ODD n))"
-  sorry
-
-lemma TWO: "2 = Suc 1"
-  sorry
-
-lemma NORM_0: "(0::nat) = (0::nat)"
-  sorry
-
-lemma num_case_compute: "nat_case f g n = (if n = 0 then f else g (PRE n))"
-  sorry
-
-lemma ADD_CLAUSES: "0 + m = m & m + 0 = m & Suc m + n = Suc (m + n) & m + Suc n = Suc (m + n)"
-  sorry
-
-lemma LESS_ADD: "(n::nat) < (m::nat) ==> EX p::nat. p + n = m"
-  sorry
-
-lemma LESS_ANTISYM: "~ ((m::nat) < (n::nat) & n < m)"
-  sorry
-
-lemma LESS_LESS_SUC: "~ (x < xa & xa < Suc x)"
-  sorry
-
-lemma FUN_EQ_LEMMA: "f x1 & ~ f x2 ==> x1 ~= x2"
-  sorry
-
-lemma LESS_NOT_SUC: "m < n & n ~= Suc m ==> Suc m < n"
-  sorry
-
-lemma LESS_0_CASES: "(0::nat) = (m::nat) | (0::nat) < m"
-  sorry
-
-lemma LESS_CASES_IMP: "~ (m::nat) < (n::nat) & m ~= n ==> n < m"
-  sorry
-
-lemma LESS_CASES: "(m::nat) < (n::nat) | n <= m"
-  sorry
-
-lemma LESS_EQ_SUC_REFL: "m <= Suc m"
-  sorry
-
-lemma LESS_ADD_NONZERO: "(n::nat) ~= (0::nat) ==> (m::nat) < m + n"
-  sorry
-
-lemma LESS_EQ_ANTISYM: "~ ((x::nat) < (xa::nat) & xa <= x)"
-  sorry
-
-lemma SUB_0: "(0::nat) - (m::nat) = (0::nat) & m - (0::nat) = m"
-  sorry
-
-lemma PRE_SUB1: "PRE m = m - 1"
-  sorry
-
-lemma MULT_CLAUSES: "0 * x = 0 &
-x * 0 = 0 &
-1 * x = x & x * 1 = x & Suc x * xa = x * xa + xa & x * Suc xa = x + x * xa"
-  sorry
-
-lemma PRE_SUB: "PRE (m - n) = PRE m - n"
-  sorry
-
-lemma ADD_EQ_1: "((m::nat) + (n::nat) = (1::nat)) =
-(m = (1::nat) & n = (0::nat) | m = (0::nat) & n = (1::nat))"
-  sorry
-
-lemma ADD_INV_0_EQ: "((m::nat) + (n::nat) = m) = (n = (0::nat))"
-  sorry
-
-lemma PRE_SUC_EQ: "0 < n ==> (m = PRE n) = (Suc m = n)"
-  sorry
-
-lemma INV_PRE_EQ: "0 < m & 0 < n ==> (PRE m = PRE n) = (m = n)"
-  sorry
-
-lemma LESS_SUC_NOT: "m < n ==> ~ n < Suc m"
-  sorry
-
-lemma ADD_EQ_SUB: "(n::nat) <= (p::nat) ==> ((m::nat) + n = p) = (m = p - n)"
-  sorry
-
-lemma LESS_ADD_1: "(xa::nat) < (x::nat) ==> EX xb::nat. x = xa + (xb + (1::nat))"
-  sorry
-
-lemma NOT_ODD_EQ_EVEN: "Suc (n + n) ~= m + m"
-  sorry
-
-lemma MULT_SUC_EQ: "(n * Suc p = m * Suc p) = (n = m)"
-  sorry
-
-lemma MULT_EXP_MONO: "(n * Suc q ^ p = m * Suc q ^ p) = (n = m)"
-  sorry
-
-lemma LESS_ADD_SUC: "m < m + Suc n"
-  sorry
-
-lemma LESS_OR_EQ_ADD: "(n::nat) < (m::nat) | (EX p::nat. n = p + m)"
-  sorry
-
-lemma WOP: "Ex (P::nat => bool) ==> EX n::nat. P n & (ALL m<n. ~ P m)"
-  sorry
-
-lemma INV_PRE_LESS: "0 < m ==> (PRE m < PRE n) = (m < n)"
-  sorry
-
-lemma INV_PRE_LESS_EQ: "0 < n ==> (PRE m <= PRE n) = (m <= n)"
-  sorry
-
-lemma SUB_EQ_EQ_0: "((m::nat) - (n::nat) = m) = (m = (0::nat) | n = (0::nat))"
-  sorry
-
-lemma SUB_LESS_OR: "(n::nat) < (m::nat) ==> n <= m - (1::nat)"
-  sorry
-
-lemma LESS_SUB_ADD_LESS: "(i::nat) < (n::nat) - (m::nat) ==> i + m < n"
-  sorry
-
-lemma LESS_EQ_SUB_LESS: "(xa::nat) <= (x::nat) ==> (x - xa < (c::nat)) = (x < xa + c)"
-  sorry
-
-lemma NOT_SUC_LESS_EQ: "(~ Suc x <= xa) = (xa <= x)"
-  sorry
-
-lemma SUB_LESS_EQ_ADD: "(m::nat) <= (p::nat) ==> (p - m <= (n::nat)) = (p <= m + n)"
-  sorry
-
-lemma SUB_CANCEL: "(xa::nat) <= (x::nat) & (xb::nat) <= x ==> (x - xa = x - xb) = (xa = xb)"
-  sorry
-
-lemma NOT_EXP_0: "Suc n ^ m ~= 0"
-  sorry
-
-lemma ZERO_LESS_EXP: "0 < Suc n ^ m"
-  sorry
-
-lemma ODD_OR_EVEN: "EX xa. x = Suc (Suc 0) * xa | x = Suc (Suc 0) * xa + 1"
-  sorry
-
-lemma LESS_EXP_SUC_MONO: "Suc (Suc m) ^ n < Suc (Suc m) ^ Suc n"
-  sorry
-
-lemma LESS_LESS_CASES: "(m::nat) = (n::nat) | m < n | n < m"
-  sorry
-
-consts
-  FACT :: "nat => nat" 
-
-specification (FACT) FACT: "FACT 0 = 1 & (ALL n. FACT (Suc n) = Suc n * FACT n)"
-  sorry
-
-lemma FACT_LESS: "0 < FACT n"
-  sorry
-
-lemma EVEN_ODD: "EVEN n = (~ ODD n)"
-  sorry
-
-lemma ODD_EVEN: "ODD x = (~ EVEN x)"
-  sorry
-
-lemma EVEN_OR_ODD: "EVEN x | ODD x"
-  sorry
-
-lemma EVEN_AND_ODD: "~ (EVEN x & ODD x)"
-  sorry
-
-lemma EVEN_ADD: "EVEN (m + n) = (EVEN m = EVEN n)"
-  sorry
-
-lemma EVEN_MULT: "EVEN (m * n) = (EVEN m | EVEN n)"
-  sorry
-
-lemma ODD_ADD: "ODD (m + n) = (ODD m ~= ODD n)"
-  sorry
-
-lemma ODD_MULT: "ODD (m * n) = (ODD m & ODD n)"
-  sorry
-
-lemma EVEN_DOUBLE: "EVEN (2 * n)"
-  sorry
-
-lemma ODD_DOUBLE: "ODD (Suc (2 * x))"
-  sorry
-
-lemma EVEN_ODD_EXISTS: "(EVEN x --> (EX m. x = 2 * m)) & (ODD x --> (EX m. x = Suc (2 * m)))"
-  sorry
-
-lemma EVEN_EXISTS: "EVEN n = (EX m. n = 2 * m)"
-  sorry
-
-lemma ODD_EXISTS: "ODD n = (EX m. n = Suc (2 * m))"
-  sorry
-
-lemma NOT_SUC_LESS_EQ_0: "~ Suc x <= 0"
-  sorry
-
-lemma NOT_NUM_EQ: "(x ~= xa) = (Suc x <= xa | Suc xa <= x)"
-  sorry
-
-lemma SUC_ADD_SYM: "Suc (m + n) = Suc n + m"
-  sorry
-
-lemma NOT_SUC_ADD_LESS_EQ: "~ Suc (m + n) <= m"
-  sorry
-
-lemma SUB_LEFT_ADD: "(m::nat) + ((n::nat) - (p::nat)) = (if n <= p then m else m + n - p)"
-  sorry
-
-lemma SUB_RIGHT_ADD: "(m::nat) - (n::nat) + (p::nat) = (if m <= n then p else m + p - n)"
-  sorry
-
-lemma SUB_LEFT_SUB: "(m::nat) - ((n::nat) - (p::nat)) = (if n <= p then m else m + p - n)"
-  sorry
-
-lemma SUB_LEFT_SUC: "Suc (m - n) = (if m <= n then Suc 0 else Suc m - n)"
-  sorry
-
-lemma SUB_LEFT_LESS_EQ: "((m::nat) <= (n::nat) - (p::nat)) = (m + p <= n | m <= (0::nat))"
-  sorry
-
-lemma SUB_RIGHT_LESS_EQ: "((m::nat) - (n::nat) <= (p::nat)) = (m <= n + p)"
-  sorry
-
-lemma SUB_RIGHT_LESS: "((m::nat) - (n::nat) < (p::nat)) = (m < n + p & (0::nat) < p)"
-  sorry
-
-lemma SUB_RIGHT_GREATER_EQ: "((p::nat) <= (m::nat) - (n::nat)) = (n + p <= m | p <= (0::nat))"
-  sorry
-
-lemma SUB_LEFT_GREATER: "((n::nat) - (p::nat) < (m::nat)) = (n < m + p & (0::nat) < m)"
-  sorry
-
-lemma SUB_RIGHT_GREATER: "((p::nat) < (m::nat) - (n::nat)) = (n + p < m)"
-  sorry
-
-lemma SUB_LEFT_EQ: "((m::nat) = (n::nat) - (p::nat)) = (m + p = n | m <= (0::nat) & n <= p)"
-  sorry
-
-lemma SUB_RIGHT_EQ: "((m::nat) - (n::nat) = (p::nat)) = (m = n + p | m <= n & p <= (0::nat))"
-  sorry
-
-lemma LE: "(ALL n::nat. (n <= (0::nat)) = (n = (0::nat))) &
-(ALL (m::nat) n::nat. (m <= Suc n) = (m = Suc n | m <= n))"
-  sorry
-
-lemma DA: "(0::nat) < (n::nat) ==> EX (x::nat) q::nat. (k::nat) = q * n + x & x < n"
-  sorry
-
-lemma DIV_LESS_EQ: "(0::nat) < (n::nat) ==> (k::nat) div n <= k"
-  sorry
-
-lemma DIV_UNIQUE: "EX r::nat. (k::nat) = (q::nat) * (n::nat) + r & r < n ==> k div n = q"
-  sorry
-
-lemma MOD_UNIQUE: "EX q::nat. (k::nat) = q * (n::nat) + (r::nat) & r < n ==> k mod n = r"
-  sorry
-
-lemma DIV_MULT: "(r::nat) < (n::nat) ==> ((q::nat) * n + r) div n = q"
-  sorry
-
-lemma MOD_EQ_0: "(0::nat) < (n::nat) ==> (k::nat) * n mod n = (0::nat)"
-  sorry
-
-lemma ZERO_MOD: "(0::nat) < (n::nat) ==> (0::nat) mod n = (0::nat)"
-  sorry
-
-lemma ZERO_DIV: "(0::nat) < (n::nat) ==> (0::nat) div n = (0::nat)"
-  sorry
-
-lemma MOD_MULT: "(r::nat) < (n::nat) ==> ((q::nat) * n + r) mod n = r"
-  sorry
-
-lemma MOD_TIMES: "(0::nat) < (n::nat) ==> ((q::nat) * n + (r::nat)) mod n = r mod n"
-  sorry
-
-lemma MOD_PLUS: "(0::nat) < (n::nat)
-==> ((j::nat) mod n + (k::nat) mod n) mod n = (j + k) mod n"
-  sorry
-
-lemma MOD_MOD: "(0::nat) < (n::nat) ==> (k::nat) mod n mod n = k mod n"
-  sorry
-
-lemma ADD_DIV_ADD_DIV: "(0::nat) < (x::nat) ==> ((xa::nat) * x + (r::nat)) div x = xa + r div x"
-  sorry
-
-lemma MOD_MULT_MOD: "(0::nat) < (n::nat) & (0::nat) < (m::nat)
-==> (x::nat) mod (n * m) mod n = x mod n"
-  sorry
-
-lemma DIVMOD_ID: "(0::nat) < (n::nat) ==> n div n = (1::nat) & n mod n = (0::nat)"
-  sorry
-
-lemma DIV_DIV_DIV_MULT: "(0::nat) < (x::nat) & (0::nat) < (xa::nat)
-==> (xb::nat) div x div xa = xb div (x * xa)"
-  sorry
-
-lemma DIV_P: "(0::nat) < (q::nat)
-==> (P::nat => bool) ((p::nat) div q) =
-    (EX (k::nat) r::nat. p = k * q + r & r < q & P k)"
-  sorry
-
-lemma MOD_P: "(0::nat) < (q::nat)
-==> (P::nat => bool) ((p::nat) mod q) =
-    (EX (k::nat) r::nat. p = k * q + r & r < q & P r)"
-  sorry
-
-lemma MOD_TIMES2: "(0::nat) < (n::nat)
-==> (j::nat) mod n * ((k::nat) mod n) mod n = j * k mod n"
-  sorry
-
-lemma MOD_COMMON_FACTOR: "(0::nat) < (n::nat) & (0::nat) < (q::nat)
-==> n * ((p::nat) mod q) = n * p mod (n * q)"
-  sorry
-
-lemma num_case_cong: "M = M' & (M' = 0 --> b = b') & (ALL n. M' = Suc n --> f n = f' n)
-==> nat_case b f M = nat_case b' f' M'"
-  sorry
-
-lemma SUC_ELIM_THM: "(ALL n. P (Suc n) n) = (ALL n>0. P n (n - 1))"
-  sorry
-
-lemma SUB_ELIM_THM: "(P::nat => bool) ((a::nat) - (b::nat)) =
-(ALL x::nat. (b = a + x --> P (0::nat)) & (a = b + x --> P x))"
-  sorry
-
-lemma PRE_ELIM_THM: "P (PRE n) = (ALL m. (n = 0 --> P 0) & (n = Suc m --> P m))"
-  sorry
-
-lemma MULT_INCREASES: "1 < m & 0 < n ==> Suc n <= m * n"
-  sorry
-
-lemma EXP_ALWAYS_BIG_ENOUGH: "(1::nat) < (b::nat) ==> EX m::nat. (n::nat) <= b ^ m"
-  sorry
-
-lemma EXP_EQ_0: "((n::nat) ^ (m::nat) = (0::nat)) = (n = (0::nat) & (0::nat) < m)"
-  sorry
-
-lemma EXP_1: "(1::nat) ^ (x::nat) = (1::nat) & x ^ (1::nat) = x"
-  sorry
-
-lemma MIN_MAX_EQ: "(min (x::nat) (xa::nat) = max x xa) = (x = xa)"
-  sorry
-
-lemma MIN_MAX_LT: "(min (x::nat) (xa::nat) < max x xa) = (x ~= xa)"
-  sorry
-
-lemma MIN_MAX_PRED: "(P::nat => bool) (m::nat) & P (n::nat) ==> P (min m n) & P (max m n)"
-  sorry
-
-lemma MIN_LT: "(min (xa::nat) (x::nat) < xa) = (xa ~= x & min xa x = x) &
-(min xa x < x) = (xa ~= x & min xa x = xa) &
-(xa < min xa x) = False & (x < min xa x) = False"
-  sorry
-
-lemma MAX_LT: "((xa::nat) < max xa (x::nat)) = (xa ~= x & max xa x = x) &
-(x < max xa x) = (xa ~= x & max xa x = xa) &
-(max xa x < xa) = False & (max xa x < x) = False"
-  sorry
-
-lemma MIN_LE: "min (xa::nat) (x::nat) <= xa & min xa x <= x"
-  sorry
-
-lemma MAX_LE: "(xa::nat) <= max xa (x::nat) & x <= max xa x"
-  sorry
-
-lemma MIN_0: "min (x::nat) (0::nat) = (0::nat) & min (0::nat) x = (0::nat)"
-  sorry
-
-lemma MAX_0: "max (x::nat) (0::nat) = x & max (0::nat) x = x"
-  sorry
-
-lemma EXISTS_GREATEST: "(Ex (P::nat => bool) & (EX x::nat. ALL y>x. ~ P y)) =
-(EX x::nat. P x & (ALL y>x. ~ P y))"
-  sorry
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL" 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/HOL" 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/HOL" 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/HOL" ind_type
-
-lemma INJ_INVERSE2: "(!!(x1::'A) (y1::'B) (x2::'A) y2::'B.
-    ((P::'A => 'B => 'C) x1 y1 = P x2 y2) = (x1 = x2 & y1 = y2))
-==> EX (x::'C => 'A) Y::'C => 'B.
-       ALL (xa::'A) y::'B. x (P xa y) = xa & Y (P xa y) = y"
-  sorry
-
-definition
-  NUMPAIR :: "nat => nat => nat"  where
-  "NUMPAIR == %x y. 2 ^ x * (2 * y + 1)"
-
-lemma NUMPAIR: "NUMPAIR x y = 2 ^ x * (2 * y + 1)"
-  sorry
-
-lemma NUMPAIR_INJ_LEMMA: "NUMPAIR x xa = NUMPAIR xb xc ==> x = xb"
-  sorry
-
-lemma NUMPAIR_INJ: "(NUMPAIR x1 y1 = NUMPAIR x2 y2) = (x1 = x2 & y1 = y2)"
-  sorry
-
-consts
-  NUMSND :: "nat => nat" 
-  NUMFST :: "nat => nat" 
-
-specification (NUMFST NUMSND) NUMPAIR_DEST: "ALL x y. NUMFST (NUMPAIR x y) = x & NUMSND (NUMPAIR x y) = y"
-  sorry
-
-definition
-  NUMSUM :: "bool => nat => nat"  where
-  "NUMSUM == %b x. if b then Suc (2 * x) else 2 * x"
-
-lemma NUMSUM: "NUMSUM b x = (if b then Suc (2 * x) else 2 * x)"
-  sorry
-
-lemma NUMSUM_INJ: "(NUMSUM b1 x1 = NUMSUM b2 x2) = (b1 = b2 & x1 = x2)"
-  sorry
-
-consts
-  NUMRIGHT :: "nat => nat" 
-  NUMLEFT :: "nat => bool" 
-
-specification (NUMLEFT NUMRIGHT) NUMSUM_DEST: "ALL x y. NUMLEFT (NUMSUM x y) = x & NUMRIGHT (NUMSUM x y) = y"
-  sorry
-
-definition
-  INJN :: "nat => nat => 'a => bool"  where
-  "INJN == %m n a. n = m"
-
-lemma INJN: "INJN m = (%n a. n = m)"
-  sorry
-
-lemma INJN_INJ: "(INJN n1 = INJN n2) = (n1 = n2)"
-  sorry
-
-definition
-  INJA :: "'a => nat => 'a => bool"  where
-  "INJA == %a n b. b = a"
-
-lemma INJA: "INJA a = (%n b. b = a)"
-  sorry
-
-lemma INJA_INJ: "(INJA a1 = INJA a2) = (a1 = a2)"
-  sorry
-
-definition
-  INJF :: "(nat => nat => 'a => bool) => nat => 'a => bool"  where
-  "INJF == %f n. f (NUMFST n) (NUMSND n)"
-
-lemma INJF: "INJF f = (%n. f (NUMFST n) (NUMSND n))"
-  sorry
-
-lemma INJF_INJ: "(INJF f1 = INJF f2) = (f1 = f2)"
-  sorry
-
-definition
-  INJP :: "(nat => 'a => bool) => (nat => 'a => bool) => nat => 'a => bool"  where
-  "INJP ==
-%f1 f2 n a. if NUMLEFT n then f1 (NUMRIGHT n) a else f2 (NUMRIGHT n) a"
-
-lemma INJP: "INJP f1 f2 =
-(%n a. if NUMLEFT n then f1 (NUMRIGHT n) a else f2 (NUMRIGHT n) a)"
-  sorry
-
-lemma INJP_INJ: "(INJP f1 f2 = INJP f1' f2') = (f1 = f1' & f2 = f2')"
-  sorry
-
-definition
-  ZCONSTR :: "nat => 'a => (nat => nat => 'a => bool) => nat => 'a => bool"  where
-  "ZCONSTR == %c i r. INJP (INJN (Suc c)) (INJP (INJA i) (INJF r))"
-
-lemma ZCONSTR: "ZCONSTR c i r = INJP (INJN (Suc c)) (INJP (INJA i) (INJF r))"
-  sorry
-
-definition
-  ZBOT :: "nat => 'a => bool"  where
-  "ZBOT == INJP (INJN 0) (SOME z. True)"
-
-lemma ZBOT: "ZBOT = INJP (INJN 0) (SOME z. True)"
-  sorry
-
-lemma ZCONSTR_ZBOT: "ZCONSTR x xa xb ~= ZBOT"
-  sorry
-
-definition
-  ZRECSPACE :: "(nat => 'a => bool) => bool"  where
-  "ZRECSPACE ==
-%a0. ALL ZRECSPACE'.
-        (ALL a0.
-            a0 = ZBOT |
-            (EX c i r. a0 = ZCONSTR c i r & (ALL n. ZRECSPACE' (r n))) -->
-            ZRECSPACE' a0) -->
-        ZRECSPACE' a0"
-
-lemma ZRECSPACE: "ZRECSPACE =
-(%a0. ALL ZRECSPACE'.
-         (ALL a0.
-             a0 = ZBOT |
-             (EX c i r. a0 = ZCONSTR c i r & (ALL n. ZRECSPACE' (r n))) -->
-             ZRECSPACE' a0) -->
-         ZRECSPACE' a0)"
-  sorry
-
-lemma ZRECSPACE_rules: "(op &::bool => bool => bool)
- ((ZRECSPACE::(nat => 'a::type => bool) => bool)
-   (ZBOT::nat => 'a::type => bool))
- ((All::(nat => bool) => bool)
-   (%c::nat.
-       (All::('a::type => bool) => bool)
-        (%i::'a::type.
-            (All::((nat => nat => 'a::type => bool) => bool) => bool)
-             (%r::nat => nat => 'a::type => bool.
-                 (op -->::bool => bool => bool)
-                  ((All::(nat => bool) => bool)
-                    (%n::nat.
-                        (ZRECSPACE::(nat => 'a::type => bool) => bool)
-                         (r n)))
-                  ((ZRECSPACE::(nat => 'a::type => bool) => bool)
-                    ((ZCONSTR::nat
-                               => 'a::type
-                                  => (nat => nat => 'a::type => bool)
-                                     => nat => 'a::type => bool)
-                      c i r))))))"
-  sorry
-
-lemma ZRECSPACE_ind: "[| x ZBOT & (ALL c i r. (ALL n. x (r n)) --> x (ZCONSTR c i r));
-   ZRECSPACE a0 |]
-==> x a0"
-  sorry
-
-lemma ZRECSPACE_cases: "ZRECSPACE a0 =
-(a0 = ZBOT | (EX c i r. a0 = ZCONSTR c i r & (ALL n. ZRECSPACE (r n))))"
-  sorry
-
-typedef (open) ('a) recspace = "Collect ZRECSPACE :: (nat \<Rightarrow> 'a\<Colon>type \<Rightarrow> bool) set"
-  sorry
-
-lemmas recspace_TY_DEF = typedef_hol2hol4 [OF type_definition_recspace]
-
-consts
-  mk_rec :: "(nat => 'a => bool) => 'a recspace" 
-  dest_rec :: "'a recspace => nat => 'a => bool" 
-
-specification (dest_rec mk_rec) recspace_repfns: "(ALL a::'a recspace. mk_rec (dest_rec a) = a) &
-(ALL r::nat => 'a => bool. ZRECSPACE r = (dest_rec (mk_rec r) = r))"
-  sorry
-
-definition
-  BOTTOM :: "'a recspace"  where
-  "BOTTOM == mk_rec ZBOT"
-
-lemma BOTTOM: "BOTTOM = mk_rec ZBOT"
-  sorry
-
-definition
-  CONSTR :: "nat => 'a => (nat => 'a recspace) => 'a recspace"  where
-  "CONSTR == %c i r. mk_rec (ZCONSTR c i (%n. dest_rec (r n)))"
-
-lemma CONSTR: "CONSTR c i r = mk_rec (ZCONSTR c i (%n. dest_rec (r n)))"
-  sorry
-
-lemma MK_REC_INJ: "[| mk_rec x = mk_rec y; ZRECSPACE x & ZRECSPACE y |] ==> x = y"
-  sorry
-
-lemma DEST_REC_INJ: "(dest_rec x = dest_rec y) = (x = y)"
-  sorry
-
-lemma CONSTR_BOT: "CONSTR c i r ~= BOTTOM"
-  sorry
-
-lemma CONSTR_INJ: "(CONSTR c1 i1 r1 = CONSTR c2 i2 r2) = (c1 = c2 & i1 = i2 & r1 = r2)"
-  sorry
-
-lemma CONSTR_IND: "P BOTTOM & (ALL c i r. (ALL n. P (r n)) --> P (CONSTR c i r)) ==> P x"
-  sorry
-
-lemma CONSTR_REC: "EX f. ALL c i r. f (CONSTR c i r) = Fn c i r (%n. f (r n))"
-  sorry
-
-consts
-  FCONS :: "'a => (nat => 'a) => nat => 'a" 
-
-specification (FCONS) FCONS: "(ALL (a::'a) f::nat => 'a. FCONS a f (0::nat) = a) &
-(ALL (a::'a) (f::nat => 'a) n::nat. FCONS a f (Suc n) = f n)"
-  sorry
-
-definition
-  FNIL :: "nat => 'a"  where
-  "FNIL == %n. SOME x. True"
-
-lemma FNIL: "FNIL n = (SOME x. True)"
-  sorry
-
-definition
-  ISO :: "('a => 'b) => ('b => 'a) => bool"  where
-  "ISO == %f g. (ALL x. f (g x) = x) & (ALL y. g (f y) = y)"
-
-lemma ISO: "ISO f g = ((ALL x. f (g x) = x) & (ALL y. g (f y) = y))"
-  sorry
-
-lemma ISO_REFL: "ISO (%x. x) (%x. x)"
-  sorry
-
-lemma ISO_FUN: "ISO (f::'a => 'c) (f'::'c => 'a) & ISO (g::'b => 'd) (g'::'d => 'b)
-==> ISO (%(h::'a => 'b) a'::'c. g (h (f' a')))
-     (%(h::'c => 'd) a::'a. g' (h (f a)))"
-  sorry
-
-lemma ISO_USAGE: "ISO f g
-==> (ALL P. All P = (ALL x. P (g x))) &
-    (ALL P. Ex P = (EX x. P (g x))) & (ALL a b. (a = g b) = (f a = b))"
-  sorry
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL" divides
-
-lemma DIVIDES_FACT: "0 < b ==> b dvd FACT b"
-  sorry
-
-lemma DIVIDES_MULT_LEFT: "((x::nat) * (xa::nat) dvd xa) = (xa = (0::nat) | x = (1::nat))"
-  sorry
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL" 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/HOL" list
-
-consts
-  EL :: "nat => 'a list => 'a" 
-
-specification (EL) EL: "(ALL l::'a list. EL (0::nat) l = hd l) &
-(ALL (l::'a list) n::nat. EL (Suc n) l = EL n (tl l))"
-  sorry
-
-lemma NULL: "(op &::bool => bool => bool)
- ((List.null::'a::type list => bool) ([]::'a::type list))
- ((All::('a::type => bool) => bool)
-   (%x::'a::type.
-       (All::('a::type list => bool) => bool)
-        (%xa::'a::type list.
-            (Not::bool => bool)
-             ((List.null::'a::type list => bool)
-               ((op #::'a::type => 'a::type list => 'a::type list) x xa)))))"
-  sorry
-
-lemma list_case_compute: "list_case (b::'b) (f::'a => 'a list => 'b) (l::'a list) =
-(if List.null l then b else f (hd l) (tl l))"
-  sorry
-
-lemma LIST_NOT_EQ: "l1 ~= l2 ==> x # l1 ~= xa # l2"
-  sorry
-
-lemma NOT_EQ_LIST: "h1 ~= h2 ==> h1 # x ~= h2 # xa"
-  sorry
-
-lemma EQ_LIST: "[| h1 = h2; l1 = l2 |] ==> h1 # l1 = h2 # l2"
-  sorry
-
-lemma CONS: "~ List.null l ==> hd l # tl l = l"
-  sorry
-
-lemma MAP_EQ_NIL: "(map (f::'a => 'b) (l::'a list) = []) = (l = []) & ([] = map f l) = (l = [])"
-  sorry
-
-lemma EVERY_EL: "list_all P l = (ALL n<length l. P (EL n l))"
-  sorry
-
-lemma EVERY_CONJ: "list_all (%x. P x & Q x) l = (list_all P l & list_all Q l)"
-  sorry
-
-lemma EVERY_MEM: "list_all P l = (ALL e. List.member l e --> P e)"
-  sorry
-
-lemma EXISTS_MEM: "list_ex P l = (EX e. List.member l e & P e)"
-  sorry
-
-lemma MEM_APPEND: "List.member (l1 @ l2) e = (List.member l1 e | List.member l2 e)"
-  sorry
-
-lemma NOT_EVERY: "(~ list_all P l) = list_ex (Not o P) l"
-  sorry
-
-lemma NOT_EXISTS: "(~ list_ex P l) = list_all (Not o P) l"
-  sorry
-
-lemma MEM_MAP: "List.member (map (f::'a => 'b) (l::'a list)) (x::'b) =
-(EX y::'a. x = f y & List.member l y)"
-  sorry
-
-lemma LENGTH_CONS: "(length l = Suc n) = (EX h l'. length l' = n & l = h # l')"
-  sorry
-
-lemma LENGTH_EQ_CONS: "(ALL l. length l = Suc n --> P l) =
-(ALL l. length l = n --> (ALL x. P (x # l)))"
-  sorry
-
-lemma LENGTH_EQ_NIL: "(ALL l. length l = 0 --> P l) = P []"
-  sorry
-
-lemma CONS_ACYCLIC: "l ~= x # l & x # l ~= l"
-  sorry
-
-lemma APPEND_eq_NIL: "(ALL (l1::'a list) l2::'a list. ([] = l1 @ l2) = (l1 = [] & l2 = [])) &
-(ALL (l1::'a list) l2::'a list. (l1 @ l2 = []) = (l1 = [] & l2 = []))"
-  sorry
-
-lemma APPEND_11: "(ALL (l1::'a list) (l2::'a list) l3::'a list.
-    (l1 @ l2 = l1 @ l3) = (l2 = l3)) &
-(ALL (l1::'a list) (l2::'a list) l3::'a list.
-    (l2 @ l1 = l3 @ l1) = (l2 = l3))"
-  sorry
-
-lemma EL_compute: "EL n l = (if n = 0 then hd l else EL (PRE n) (tl l))"
-  sorry
-
-lemma WF_LIST_PRED: "WF (%L1 L2. EX h. L2 = h # L1)"
-  sorry
-
-lemma list_size_cong: "M = N & (ALL x. List.member N x --> f x = f' x)
-==> HOL4Compat.list_size f M = HOL4Compat.list_size f' N"
-  sorry
-
-lemma FOLDR_CONG: "l = l' & b = b' & (ALL x a. List.member l' x --> f x a = f' x a)
-==> foldr f l b = foldr f' l' b'"
-  sorry
-
-lemma FOLDL_CONG: "l = l' & b = b' & (ALL x a. List.member l' x --> f a x = f' a x)
-==> foldl f b l = foldl f' b' l'"
-  sorry
-
-lemma MAP_CONG: "l1 = l2 & (ALL x. List.member l2 x --> f x = f' x) ==> map f l1 = map f' l2"
-  sorry
-
-lemma EXISTS_CONG: "l1 = l2 & (ALL x. List.member l2 x --> P x = P' x)
-==> list_ex P l1 = list_ex P' l2"
-  sorry
-
-lemma EVERY_CONG: "l1 = l2 & (ALL x. List.member l2 x --> P x = P' x)
-==> list_all P l1 = list_all P' l2"
-  sorry
-
-lemma EVERY_MONOTONIC: "[| !!x. P x ==> Q x; list_all P l |] ==> list_all Q l"
-  sorry
-
-lemma LENGTH_ZIP: "length l1 = length l2
-==> length (zip l1 l2) = length l1 & length (zip l1 l2) = length l2"
-  sorry
-
-lemma LENGTH_UNZIP: "length (fst (unzip pl)) = length pl & length (snd (unzip pl)) = length pl"
-  sorry
-
-lemma ZIP_UNZIP: "ZIP (unzip l) = l"
-  sorry
-
-lemma UNZIP_ZIP: "length l1 = length l2 ==> unzip (zip l1 l2) = (l1, l2)"
-  sorry
-
-lemma ZIP_MAP: "length l1 = length l2
-==> zip (map f1 l1) l2 = map (%p. (f1 (fst p), snd p)) (zip l1 l2) &
-    zip l1 (map f2 l2) = map (%p. (fst p, f2 (snd p))) (zip l1 l2)"
-  sorry
-
-lemma MEM_ZIP: "length l1 = length l2
-==> List.member (zip l1 l2) p = (EX n<length l1. p = (EL n l1, EL n l2))"
-  sorry
-
-lemma EL_ZIP: "length l1 = length l2 & n < length l1
-==> EL n (zip l1 l2) = (EL n l1, EL n l2)"
-  sorry
-
-lemma MAP2_ZIP: "length l1 = length l2 ==> map2 f l1 l2 = map (%(x, y). f x y) (zip l1 l2)"
-  sorry
-
-lemma MEM_EL: "List.member l x = (EX n<length l. x = EL n l)"
-  sorry
-
-lemma LAST_CONS: "(ALL x::'a. last [x] = x) &
-(ALL (x::'a) (xa::'a) xb::'a list. last (x # xa # xb) = last (xa # xb))"
-  sorry
-
-lemma FRONT_CONS: "(ALL x::'a. butlast [x] = []) &
-(ALL (x::'a) (xa::'a) xb::'a list.
-    butlast (x # xa # xb) = x # butlast (xa # xb))"
-  sorry
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL" pred_set
-
-lemma EXTENSION: "(s = t) = (ALL x. IN x s = IN x t)"
-  sorry
-
-lemma NOT_EQUAL_SETS: "(x ~= xa) = (EX xb. IN xb xa = (~ IN xb x))"
-  sorry
-
-lemma NUM_SET_WOP: "(EX n::nat. IN n (s::nat => bool)) =
-(EX n::nat. IN n s & (ALL m::nat. IN m s --> n <= m))"
-  sorry
-
-consts
-  GSPEC :: "('b => 'a * bool) => 'a => bool" 
-
-specification (GSPEC) GSPECIFICATION: "ALL (f::'b => 'a * bool) v::'a. IN v (GSPEC f) = (EX x::'b. (v, True) = f x)"
-  sorry
-
-lemma SET_MINIMUM: "(EX x::'a. IN x (s::'a => bool)) =
-(EX x::'a. IN x s & (ALL y::'a. IN y s --> (M::'a => nat) x <= M y))"
-  sorry
-
-definition
-  EMPTY :: "'a => bool"  where
-  "EMPTY == %x. False"
-
-lemma EMPTY_DEF: "EMPTY = (%x. False)"
-  sorry
-
-lemma NOT_IN_EMPTY: "~ IN x EMPTY"
-  sorry
-
-lemma MEMBER_NOT_EMPTY: "(EX xa. IN xa x) = (x ~= EMPTY)"
-  sorry
-
-definition
-  UNIV :: "'a => bool"  where
-  "UNIV == %x. True"
-
-lemma UNIV_DEF: "pred_set.UNIV = (%x. True)"
-  sorry
-
-lemma IN_UNIV: "IN x pred_set.UNIV"
-  sorry
-
-lemma UNIV_NOT_EMPTY: "pred_set.UNIV ~= EMPTY"
-  sorry
-
-lemma EMPTY_NOT_UNIV: "EMPTY ~= pred_set.UNIV"
-  sorry
-
-lemma EQ_UNIV: "(ALL x. IN x s) = (s = pred_set.UNIV)"
-  sorry
-
-definition
-  SUBSET :: "('a => bool) => ('a => bool) => bool"  where
-  "SUBSET == %s t. ALL x. IN x s --> IN x t"
-
-lemma SUBSET_DEF: "SUBSET s t = (ALL x. IN x s --> IN x t)"
-  sorry
-
-lemma SUBSET_TRANS: "SUBSET x xa & SUBSET xa xb ==> SUBSET x xb"
-  sorry
-
-lemma SUBSET_REFL: "SUBSET x x"
-  sorry
-
-lemma SUBSET_ANTISYM: "SUBSET x xa & SUBSET xa x ==> x = xa"
-  sorry
-
-lemma EMPTY_SUBSET: "SUBSET EMPTY x"
-  sorry
-
-lemma SUBSET_EMPTY: "SUBSET x EMPTY = (x = EMPTY)"
-  sorry
-
-lemma SUBSET_UNIV: "SUBSET x pred_set.UNIV"
-  sorry
-
-lemma UNIV_SUBSET: "SUBSET pred_set.UNIV x = (x = pred_set.UNIV)"
-  sorry
-
-definition
-  PSUBSET :: "('a => bool) => ('a => bool) => bool"  where
-  "PSUBSET == %s t. SUBSET s t & s ~= t"
-
-lemma PSUBSET_DEF: "PSUBSET s t = (SUBSET s t & s ~= t)"
-  sorry
-
-lemma PSUBSET_TRANS: "PSUBSET x xa & PSUBSET xa xb ==> PSUBSET x xb"
-  sorry
-
-lemma PSUBSET_IRREFL: "~ PSUBSET x x"
-  sorry
-
-lemma NOT_PSUBSET_EMPTY: "~ PSUBSET x EMPTY"
-  sorry
-
-lemma NOT_UNIV_PSUBSET: "~ PSUBSET pred_set.UNIV x"
-  sorry
-
-lemma PSUBSET_UNIV: "PSUBSET x pred_set.UNIV = (EX xa. ~ IN xa x)"
-  sorry
-
-definition
-  UNION :: "('a => bool) => ('a => bool) => 'a => bool"  where
-  "UNION == %s t. GSPEC (%x. (x, IN x s | IN x t))"
-
-lemma UNION_DEF: "pred_set.UNION s t = GSPEC (%x. (x, IN x s | IN x t))"
-  sorry
-
-lemma IN_UNION: "IN xb (pred_set.UNION x xa) = (IN xb x | IN xb xa)"
-  sorry
-
-lemma UNION_ASSOC: "pred_set.UNION x (pred_set.UNION xa xb) =
-pred_set.UNION (pred_set.UNION x xa) xb"
-  sorry
-
-lemma UNION_IDEMPOT: "pred_set.UNION x x = x"
-  sorry
-
-lemma UNION_COMM: "pred_set.UNION x xa = pred_set.UNION xa x"
-  sorry
-
-lemma SUBSET_UNION: "(ALL (x::'a => bool) xa::'a => bool. SUBSET x (pred_set.UNION x xa)) &
-(ALL (x::'a => bool) xa::'a => bool. SUBSET x (pred_set.UNION xa x))"
-  sorry
-
-lemma UNION_SUBSET: "SUBSET (pred_set.UNION s t) u = (SUBSET s u & SUBSET t u)"
-  sorry
-
-lemma SUBSET_UNION_ABSORPTION: "SUBSET x xa = (pred_set.UNION x xa = xa)"
-  sorry
-
-lemma UNION_EMPTY: "(ALL x::'a => bool. pred_set.UNION EMPTY x = x) &
-(ALL x::'a => bool. pred_set.UNION x EMPTY = x)"
-  sorry
-
-lemma UNION_UNIV: "(ALL x::'a => bool. pred_set.UNION pred_set.UNIV x = pred_set.UNIV) &
-(ALL x::'a => bool. pred_set.UNION x pred_set.UNIV = pred_set.UNIV)"
-  sorry
-
-lemma EMPTY_UNION: "(pred_set.UNION x xa = EMPTY) = (x = EMPTY & xa = EMPTY)"
-  sorry
-
-definition
-  INTER :: "('a => bool) => ('a => bool) => 'a => bool"  where
-  "INTER == %s t. GSPEC (%x. (x, IN x s & IN x t))"
-
-lemma INTER_DEF: "pred_set.INTER s t = GSPEC (%x. (x, IN x s & IN x t))"
-  sorry
-
-lemma IN_INTER: "IN xb (pred_set.INTER x xa) = (IN xb x & IN xb xa)"
-  sorry
-
-lemma INTER_ASSOC: "pred_set.INTER x (pred_set.INTER xa xb) =
-pred_set.INTER (pred_set.INTER x xa) xb"
-  sorry
-
-lemma INTER_IDEMPOT: "pred_set.INTER x x = x"
-  sorry
-
-lemma INTER_COMM: "pred_set.INTER x xa = pred_set.INTER xa x"
-  sorry
-
-lemma INTER_SUBSET: "(ALL (x::'a => bool) xa::'a => bool. SUBSET (pred_set.INTER x xa) x) &
-(ALL (x::'a => bool) xa::'a => bool. SUBSET (pred_set.INTER xa x) x)"
-  sorry
-
-lemma SUBSET_INTER: "SUBSET s (pred_set.INTER t u) = (SUBSET s t & SUBSET s u)"
-  sorry
-
-lemma SUBSET_INTER_ABSORPTION: "SUBSET x xa = (pred_set.INTER x xa = x)"
-  sorry
-
-lemma INTER_EMPTY: "(ALL x::'a => bool. pred_set.INTER EMPTY x = EMPTY) &
-(ALL x::'a => bool. pred_set.INTER x EMPTY = EMPTY)"
-  sorry
-
-lemma INTER_UNIV: "(ALL x::'a => bool. pred_set.INTER pred_set.UNIV x = x) &
-(ALL x::'a => bool. pred_set.INTER x pred_set.UNIV = x)"
-  sorry
-
-lemma UNION_OVER_INTER: "pred_set.INTER x (pred_set.UNION xa xb) =
-pred_set.UNION (pred_set.INTER x xa) (pred_set.INTER x xb)"
-  sorry
-
-lemma INTER_OVER_UNION: "pred_set.UNION x (pred_set.INTER xa xb) =
-pred_set.INTER (pred_set.UNION x xa) (pred_set.UNION x xb)"
-  sorry
-
-definition
-  DISJOINT :: "('a => bool) => ('a => bool) => bool"  where
-  "DISJOINT == %s t. pred_set.INTER s t = EMPTY"
-
-lemma DISJOINT_DEF: "DISJOINT s t = (pred_set.INTER s t = EMPTY)"
-  sorry
-
-lemma IN_DISJOINT: "DISJOINT x xa = (~ (EX xb. IN xb x & IN xb xa))"
-  sorry
-
-lemma DISJOINT_SYM: "DISJOINT x xa = DISJOINT xa x"
-  sorry
-
-lemma DISJOINT_EMPTY: "DISJOINT EMPTY x & DISJOINT x EMPTY"
-  sorry
-
-lemma DISJOINT_EMPTY_REFL: "(x = EMPTY) = DISJOINT x x"
-  sorry
-
-lemma DISJOINT_UNION: "DISJOINT (pred_set.UNION x xa) xb = (DISJOINT x xb & DISJOINT xa xb)"
-  sorry
-
-lemma DISJOINT_UNION_BOTH: "DISJOINT (pred_set.UNION s t) u = (DISJOINT s u & DISJOINT t u) &
-DISJOINT u (pred_set.UNION s t) = (DISJOINT s u & DISJOINT t u)"
-  sorry
-
-definition
-  DIFF :: "('a => bool) => ('a => bool) => 'a => bool"  where
-  "DIFF == %s t. GSPEC (%x. (x, IN x s & ~ IN x t))"
-
-lemma DIFF_DEF: "DIFF s t = GSPEC (%x. (x, IN x s & ~ IN x t))"
-  sorry
-
-lemma IN_DIFF: "IN x (DIFF s t) = (IN x s & ~ IN x t)"
-  sorry
-
-lemma DIFF_EMPTY: "DIFF s EMPTY = s"
-  sorry
-
-lemma EMPTY_DIFF: "DIFF EMPTY s = EMPTY"
-  sorry
-
-lemma DIFF_UNIV: "DIFF s pred_set.UNIV = EMPTY"
-  sorry
-
-lemma DIFF_DIFF: "DIFF (DIFF x xa) xa = DIFF x xa"
-  sorry
-
-lemma DIFF_EQ_EMPTY: "DIFF x x = EMPTY"
-  sorry
-
-definition
-  INSERT :: "'a => ('a => bool) => 'a => bool"  where
-  "INSERT == %x s. GSPEC (%y. (y, y = x | IN y s))"
-
-lemma INSERT_DEF: "INSERT x s = GSPEC (%y. (y, y = x | IN y s))"
-  sorry
-
-lemma IN_INSERT: "IN x (INSERT xa xb) = (x = xa | IN x xb)"
-  sorry
-
-lemma COMPONENT: "IN x (INSERT x xa)"
-  sorry
-
-lemma SET_CASES: "x = EMPTY | (EX xa xb. x = INSERT xa xb & ~ IN xa xb)"
-  sorry
-
-lemma DECOMPOSITION: "IN x s = (EX t. s = INSERT x t & ~ IN x t)"
-  sorry
-
-lemma ABSORPTION: "IN x xa = (INSERT x xa = xa)"
-  sorry
-
-lemma INSERT_INSERT: "INSERT x (INSERT x xa) = INSERT x xa"
-  sorry
-
-lemma INSERT_COMM: "INSERT x (INSERT xa xb) = INSERT xa (INSERT x xb)"
-  sorry
-
-lemma INSERT_UNIV: "INSERT x pred_set.UNIV = pred_set.UNIV"
-  sorry
-
-lemma NOT_INSERT_EMPTY: "INSERT x xa ~= EMPTY"
-  sorry
-
-lemma NOT_EMPTY_INSERT: "EMPTY ~= INSERT x xa"
-  sorry
-
-lemma INSERT_UNION: "pred_set.UNION (INSERT x s) t =
-(if IN x t then pred_set.UNION s t else INSERT x (pred_set.UNION s t))"
-  sorry
-
-lemma INSERT_UNION_EQ: "pred_set.UNION (INSERT x s) t = INSERT x (pred_set.UNION s t)"
-  sorry
-
-lemma INSERT_INTER: "pred_set.INTER (INSERT x s) t =
-(if IN x t then INSERT x (pred_set.INTER s t) else pred_set.INTER s t)"
-  sorry
-
-lemma DISJOINT_INSERT: "DISJOINT (INSERT x xa) xb = (DISJOINT xa xb & ~ IN x xb)"
-  sorry
-
-lemma INSERT_SUBSET: "SUBSET (INSERT x xa) xb = (IN x xb & SUBSET xa xb)"
-  sorry
-
-lemma SUBSET_INSERT: "~ IN x xa ==> SUBSET xa (INSERT x xb) = SUBSET xa xb"
-  sorry
-
-lemma INSERT_DIFF: "DIFF (INSERT x s) t = (if IN x t then DIFF s t else INSERT x (DIFF s t))"
-  sorry
-
-definition
-  DELETE :: "('a => bool) => 'a => 'a => bool"  where
-  "DELETE == %s x. DIFF s (INSERT x EMPTY)"
-
-lemma DELETE_DEF: "DELETE s x = DIFF s (INSERT x EMPTY)"
-  sorry
-
-lemma IN_DELETE: "IN xa (DELETE x xb) = (IN xa x & xa ~= xb)"
-  sorry
-
-lemma DELETE_NON_ELEMENT: "(~ IN x xa) = (DELETE xa x = xa)"
-  sorry
-
-lemma IN_DELETE_EQ: "(IN x s = IN x' s) = (IN x (DELETE s x') = IN x' (DELETE s x))"
-  sorry
-
-lemma EMPTY_DELETE: "DELETE EMPTY x = EMPTY"
-  sorry
-
-lemma DELETE_DELETE: "DELETE (DELETE xa x) x = DELETE xa x"
-  sorry
-
-lemma DELETE_COMM: "DELETE (DELETE xb x) xa = DELETE (DELETE xb xa) x"
-  sorry
-
-lemma DELETE_SUBSET: "SUBSET (DELETE xa x) xa"
-  sorry
-
-lemma SUBSET_DELETE: "SUBSET xa (DELETE xb x) = (~ IN x xa & SUBSET xa xb)"
-  sorry
-
-lemma SUBSET_INSERT_DELETE: "SUBSET s (INSERT x t) = SUBSET (DELETE s x) t"
-  sorry
-
-lemma DIFF_INSERT: "DIFF x (INSERT xb xa) = DIFF (DELETE x xb) xa"
-  sorry
-
-lemma PSUBSET_INSERT_SUBSET: "PSUBSET x xa = (EX xb. ~ IN xb x & SUBSET (INSERT xb x) xa)"
-  sorry
-
-lemma PSUBSET_MEMBER: "PSUBSET s t = (SUBSET s t & (EX y. IN y t & ~ IN y s))"
-  sorry
-
-lemma DELETE_INSERT: "DELETE (INSERT x xb) xa =
-(if x = xa then DELETE xb xa else INSERT x (DELETE xb xa))"
-  sorry
-
-lemma INSERT_DELETE: "IN x xa ==> INSERT x (DELETE xa x) = xa"
-  sorry
-
-lemma DELETE_INTER: "pred_set.INTER (DELETE x xb) xa = DELETE (pred_set.INTER x xa) xb"
-  sorry
-
-lemma DISJOINT_DELETE_SYM: "DISJOINT (DELETE x xb) xa = DISJOINT (DELETE xa xb) x"
-  sorry
-
-consts
-  CHOICE :: "('a => bool) => 'a" 
-
-specification (CHOICE) CHOICE_DEF: "ALL x. x ~= EMPTY --> IN (CHOICE x) x"
-  sorry
-
-definition
-  REST :: "('a => bool) => 'a => bool"  where
-  "REST == %s. DELETE s (CHOICE s)"
-
-lemma REST_DEF: "REST s = DELETE s (CHOICE s)"
-  sorry
-
-lemma CHOICE_NOT_IN_REST: "~ IN (CHOICE x) (REST x)"
-  sorry
-
-lemma CHOICE_INSERT_REST: "s ~= EMPTY ==> INSERT (CHOICE s) (REST s) = s"
-  sorry
-
-lemma REST_SUBSET: "SUBSET (REST x) x"
-  sorry
-
-lemma REST_PSUBSET: "x ~= EMPTY ==> PSUBSET (REST x) x"
-  sorry
-
-definition
-  SING :: "('a => bool) => bool"  where
-  "SING == %s. EX x. s = INSERT x EMPTY"
-
-lemma SING_DEF: "SING s = (EX x. s = INSERT x EMPTY)"
-  sorry
-
-lemma SING: "SING (INSERT x EMPTY)"
-  sorry
-
-lemma IN_SING: "IN x (INSERT xa EMPTY) = (x = xa)"
-  sorry
-
-lemma NOT_SING_EMPTY: "INSERT x EMPTY ~= EMPTY"
-  sorry
-
-lemma NOT_EMPTY_SING: "EMPTY ~= INSERT x EMPTY"
-  sorry
-
-lemma EQUAL_SING: "(INSERT x EMPTY = INSERT xa EMPTY) = (x = xa)"
-  sorry
-
-lemma DISJOINT_SING_EMPTY: "DISJOINT (INSERT x EMPTY) EMPTY"
-  sorry
-
-lemma INSERT_SING_UNION: "INSERT xa x = pred_set.UNION (INSERT xa EMPTY) x"
-  sorry
-
-lemma SING_DELETE: "DELETE (INSERT x EMPTY) x = EMPTY"
-  sorry
-
-lemma DELETE_EQ_SING: "IN xa x ==> (DELETE x xa = EMPTY) = (x = INSERT xa EMPTY)"
-  sorry
-
-lemma CHOICE_SING: "CHOICE (INSERT x EMPTY) = x"
-  sorry
-
-lemma REST_SING: "REST (INSERT x EMPTY) = EMPTY"
-  sorry
-
-lemma SING_IFF_EMPTY_REST: "SING x = (x ~= EMPTY & REST x = EMPTY)"
-  sorry
-
-definition
-  IMAGE :: "('a => 'b) => ('a => bool) => 'b => bool"  where
-  "IMAGE == %f s. GSPEC (%x. (f x, IN x s))"
-
-lemma IMAGE_DEF: "IMAGE (f::'a => 'b) (s::'a => bool) = GSPEC (%x::'a. (f x, IN x s))"
-  sorry
-
-lemma IN_IMAGE: "IN (x::'b) (IMAGE (xb::'a => 'b) (xa::'a => bool)) =
-(EX xc::'a. x = xb xc & IN xc xa)"
-  sorry
-
-lemma IMAGE_IN: "IN x xa ==> IN (xb x) (IMAGE xb xa)"
-  sorry
-
-lemma IMAGE_EMPTY: "IMAGE (x::'a => 'b) EMPTY = EMPTY"
-  sorry
-
-lemma IMAGE_ID: "IMAGE (%x. x) x = x"
-  sorry
-
-lemma IMAGE_COMPOSE: "IMAGE ((x::'b => 'c) o (xa::'a => 'b)) (xb::'a => bool) =
-IMAGE x (IMAGE xa xb)"
-  sorry
-
-lemma IMAGE_INSERT: "IMAGE (x::'a => 'b) (INSERT (xa::'a) (xb::'a => bool)) =
-INSERT (x xa) (IMAGE x xb)"
-  sorry
-
-lemma IMAGE_EQ_EMPTY: "(IMAGE (x::'a => 'b) (s::'a => bool) = EMPTY) = (s = EMPTY)"
-  sorry
-
-lemma IMAGE_DELETE: "~ IN x s ==> IMAGE f (DELETE s x) = IMAGE f s"
-  sorry
-
-lemma IMAGE_UNION: "IMAGE (x::'a => 'b) (pred_set.UNION (xa::'a => bool) (xb::'a => bool)) =
-pred_set.UNION (IMAGE x xa) (IMAGE x xb)"
-  sorry
-
-lemma IMAGE_SUBSET: "SUBSET x xa ==> SUBSET (IMAGE xb x) (IMAGE xb xa)"
-  sorry
-
-lemma IMAGE_INTER: "SUBSET
- (IMAGE (f::'a => 'b) (pred_set.INTER (s::'a => bool) (t::'a => bool)))
- (pred_set.INTER (IMAGE f s) (IMAGE f t))"
-  sorry
-
-definition
-  INJ :: "('a => 'b) => ('a => bool) => ('b => bool) => bool"  where
-  "INJ ==
-%f s t.
-   (ALL x. IN x s --> IN (f x) t) &
-   (ALL x y. IN x s & IN y s --> f x = f y --> x = y)"
-
-lemma INJ_DEF: "INJ f s t =
-((ALL x. IN x s --> IN (f x) t) &
- (ALL x y. IN x s & IN y s --> f x = f y --> x = y))"
-  sorry
-
-lemma INJ_ID: "INJ (%x. x) x x"
-  sorry
-
-lemma INJ_COMPOSE: "INJ x xb xc & INJ xa xc xd ==> INJ (xa o x) xb xd"
-  sorry
-
-lemma INJ_EMPTY: "All (INJ (x::'a => 'b) EMPTY) &
-(ALL xa::'a => bool. INJ x xa EMPTY = (xa = EMPTY))"
-  sorry
-
-definition
-  SURJ :: "('a => 'b) => ('a => bool) => ('b => bool) => bool"  where
-  "SURJ ==
-%f s t.
-   (ALL x. IN x s --> IN (f x) t) &
-   (ALL x. IN x t --> (EX y. IN y s & f y = x))"
-
-lemma SURJ_DEF: "SURJ f s t =
-((ALL x. IN x s --> IN (f x) t) &
- (ALL x. IN x t --> (EX y. IN y s & f y = x)))"
-  sorry
-
-lemma SURJ_ID: "SURJ (%x. x) x x"
-  sorry
-
-lemma SURJ_COMPOSE: "SURJ x xb xc & SURJ xa xc xd ==> SURJ (xa o x) xb xd"
-  sorry
-
-lemma SURJ_EMPTY: "(ALL xa::'b => bool. SURJ (x::'a => 'b) EMPTY xa = (xa = EMPTY)) &
-(ALL xa::'a => bool. SURJ x xa EMPTY = (xa = EMPTY))"
-  sorry
-
-lemma IMAGE_SURJ: "SURJ x xa xb = (IMAGE x xa = xb)"
-  sorry
-
-definition
-  BIJ :: "('a => 'b) => ('a => bool) => ('b => bool) => bool"  where
-  "BIJ == %f s t. INJ f s t & SURJ f s t"
-
-lemma BIJ_DEF: "BIJ f s t = (INJ f s t & SURJ f s t)"
-  sorry
-
-lemma BIJ_ID: "BIJ (%x. x) x x"
-  sorry
-
-lemma BIJ_EMPTY: "(ALL xa::'b => bool. BIJ (x::'a => 'b) EMPTY xa = (xa = EMPTY)) &
-(ALL xa::'a => bool. BIJ x xa EMPTY = (xa = EMPTY))"
-  sorry
-
-lemma BIJ_COMPOSE: "BIJ x xb xc & BIJ xa xc xd ==> BIJ (xa o x) xb xd"
-  sorry
-
-consts
-  LINV :: "('a => 'b) => ('a => bool) => 'b => 'a" 
-
-specification (LINV) LINV_DEF: "ALL f s t. INJ f s t --> (ALL x. IN x s --> LINV f s (f x) = x)"
-  sorry
-
-consts
-  RINV :: "('a => 'b) => ('a => bool) => 'b => 'a" 
-
-specification (RINV) RINV_DEF: "ALL f s t. SURJ f s t --> (ALL x. IN x t --> f (RINV f s x) = x)"
-  sorry
-
-definition
-  FINITE :: "('a => bool) => bool"  where
-  "FINITE ==
-%s. ALL P. P EMPTY & (ALL s. P s --> (ALL e. P (INSERT e s))) --> P s"
-
-lemma FINITE_DEF: "FINITE s =
-(ALL P. P EMPTY & (ALL s. P s --> (ALL e. P (INSERT e s))) --> P s)"
-  sorry
-
-lemma FINITE_EMPTY: "FINITE EMPTY"
-  sorry
-
-lemma FINITE_INDUCT: "[| P EMPTY &
-   (ALL s. FINITE s & P s --> (ALL e. ~ IN e s --> P (INSERT e s)));
-   FINITE s |]
-==> P s"
-  sorry
-
-lemma FINITE_INSERT: "FINITE (INSERT x s) = FINITE s"
-  sorry
-
-lemma FINITE_DELETE: "FINITE (DELETE s x) = FINITE s"
-  sorry
-
-lemma FINITE_UNION: "FINITE (pred_set.UNION s t) = (FINITE s & FINITE t)"
-  sorry
-
-lemma INTER_FINITE: "FINITE s ==> FINITE (pred_set.INTER s t)"
-  sorry
-
-lemma SUBSET_FINITE: "[| FINITE s; SUBSET t s |] ==> FINITE t"
-  sorry
-
-lemma PSUBSET_FINITE: "[| FINITE x; PSUBSET xa x |] ==> FINITE xa"
-  sorry
-
-lemma FINITE_DIFF: "FINITE s ==> FINITE (DIFF s t)"
-  sorry
-
-lemma FINITE_SING: "FINITE (INSERT x EMPTY)"
-  sorry
-
-lemma SING_FINITE: "SING x ==> FINITE x"
-  sorry
-
-lemma IMAGE_FINITE: "FINITE s ==> FINITE (IMAGE f s)"
-  sorry
-
-consts
-  CARD :: "('a => bool) => nat" 
-
-specification (CARD) CARD_DEF: "(op &::bool => bool => bool)
- ((op =::nat => nat => bool)
-   ((CARD::('a::type => bool) => nat) (EMPTY::'a::type => bool)) (0::nat))
- ((All::(('a::type => bool) => bool) => bool)
-   (%s::'a::type => bool.
-       (op -->::bool => bool => bool)
-        ((FINITE::('a::type => bool) => bool) s)
-        ((All::('a::type => bool) => bool)
-          (%x::'a::type.
-              (op =::nat => nat => bool)
-               ((CARD::('a::type => bool) => nat)
-                 ((INSERT::'a::type
-                           => ('a::type => bool) => 'a::type => bool)
-                   x s))
-               ((If::bool => nat => nat => nat)
-                 ((IN::'a::type => ('a::type => bool) => bool) x s)
-                 ((CARD::('a::type => bool) => nat) s)
-                 ((Suc::nat => nat)
-                   ((CARD::('a::type => bool) => nat) s)))))))"
-  sorry
-
-lemma CARD_EMPTY: "CARD EMPTY = 0"
-  sorry
-
-lemma CARD_INSERT: "FINITE s ==> CARD (INSERT x s) = (if IN x s then CARD s else Suc (CARD s))"
-  sorry
-
-lemma CARD_EQ_0: "FINITE s ==> (CARD s = 0) = (s = EMPTY)"
-  sorry
-
-lemma CARD_DELETE: "FINITE s ==> CARD (DELETE s x) = (if IN x s then CARD s - 1 else CARD s)"
-  sorry
-
-lemma CARD_INTER_LESS_EQ: "FINITE s ==> CARD (pred_set.INTER s t) <= CARD s"
-  sorry
-
-lemma CARD_UNION: "[| FINITE s; FINITE t |]
-==> CARD (pred_set.UNION s t) + CARD (pred_set.INTER s t) = CARD s + CARD t"
-  sorry
-
-lemma CARD_SUBSET: "[| FINITE s; SUBSET t s |] ==> CARD t <= CARD s"
-  sorry
-
-lemma CARD_PSUBSET: "[| FINITE s; PSUBSET t s |] ==> CARD t < CARD s"
-  sorry
-
-lemma CARD_SING: "CARD (INSERT x EMPTY) = 1"
-  sorry
-
-lemma SING_IFF_CARD1: "SING x = (CARD x = 1 & FINITE x)"
-  sorry
-
-lemma CARD_DIFF: "[| FINITE t; FINITE s |]
-==> CARD (DIFF s t) = CARD s - CARD (pred_set.INTER s t)"
-  sorry
-
-lemma LESS_CARD_DIFF: "[| FINITE t; FINITE s; CARD t < CARD s |] ==> 0 < CARD (DIFF s t)"
-  sorry
-
-lemma FINITE_COMPLETE_INDUCTION: "[| !!x. [| !!y. PSUBSET y x ==> P y; FINITE x |] ==> P x; FINITE x |]
-==> P x"
-  sorry
-
-definition
-  INFINITE :: "('a => bool) => bool"  where
-  "INFINITE == %s. ~ FINITE s"
-
-lemma INFINITE_DEF: "INFINITE s = (~ FINITE s)"
-  sorry
-
-lemma NOT_IN_FINITE: "(op =::bool => bool => bool)
- ((INFINITE::('a::type => bool) => bool) (pred_set.UNIV::'a::type => bool))
- ((All::(('a::type => bool) => bool) => bool)
-   (%s::'a::type => bool.
-       (op -->::bool => bool => bool)
-        ((FINITE::('a::type => bool) => bool) s)
-        ((Ex::('a::type => bool) => bool)
-          (%x::'a::type.
-              (Not::bool => bool)
-               ((IN::'a::type => ('a::type => bool) => bool) x s)))))"
-  sorry
-
-lemma INFINITE_INHAB: "INFINITE x ==> EX xa. IN xa x"
-  sorry
-
-lemma IMAGE_11_INFINITE: "[| !!x y. f x = f y ==> x = y; INFINITE s |] ==> INFINITE (IMAGE f s)"
-  sorry
-
-lemma INFINITE_SUBSET: "[| INFINITE x; SUBSET x xa |] ==> INFINITE xa"
-  sorry
-
-lemma IN_INFINITE_NOT_FINITE: "INFINITE x & FINITE xa ==> EX xb. IN xb x & ~ IN xb xa"
-  sorry
-
-lemma INFINITE_UNIV: "(op =::bool => bool => bool)
- ((INFINITE::('a::type => bool) => bool) (pred_set.UNIV::'a::type => bool))
- ((Ex::(('a::type => 'a::type) => bool) => bool)
-   (%f::'a::type => 'a::type.
-       (op &::bool => bool => bool)
-        ((All::('a::type => bool) => bool)
-          (%x::'a::type.
-              (All::('a::type => bool) => bool)
-               (%y::'a::type.
-                   (op -->::bool => bool => bool)
-                    ((op =::'a::type => 'a::type => bool) (f x) (f y))
-                    ((op =::'a::type => 'a::type => bool) x y))))
-        ((Ex::('a::type => bool) => bool)
-          (%y::'a::type.
-              (All::('a::type => bool) => bool)
-               (%x::'a::type.
-                   (op ~=::'a::type => 'a::type => bool) (f x) y)))))"
-  sorry
-
-lemma FINITE_PSUBSET_INFINITE: "INFINITE x = (ALL xa. FINITE xa --> SUBSET xa x --> PSUBSET xa x)"
-  sorry
-
-lemma FINITE_PSUBSET_UNIV: "(op =::bool => bool => bool)
- ((INFINITE::('a::type => bool) => bool) (pred_set.UNIV::'a::type => bool))
- ((All::(('a::type => bool) => bool) => bool)
-   (%s::'a::type => bool.
-       (op -->::bool => bool => bool)
-        ((FINITE::('a::type => bool) => bool) s)
-        ((PSUBSET::('a::type => bool) => ('a::type => bool) => bool) s
-          (pred_set.UNIV::'a::type => bool))))"
-  sorry
-
-lemma INFINITE_DIFF_FINITE: "INFINITE s & FINITE t ==> DIFF s t ~= EMPTY"
-  sorry
-
-lemma FINITE_ISO_NUM: "FINITE s
-==> EX f. (ALL n m. n < CARD s & m < CARD s --> f n = f m --> n = m) &
-          s = GSPEC (%n. (f n, n < CARD s))"
-  sorry
-
-lemma FINITE_WEAK_ENUMERATE: "FINITE (x::'a => bool) =
-(EX (f::nat => 'a) b::nat. ALL e::'a. IN e x = (EX n<b. e = f n))"
-  sorry
-
-definition
-  BIGUNION :: "(('a => bool) => bool) => 'a => bool"  where
-  "BIGUNION == %P. GSPEC (%x. (x, EX p. IN p P & IN x p))"
-
-lemma BIGUNION: "BIGUNION P = GSPEC (%x. (x, EX p. IN p P & IN x p))"
-  sorry
-
-lemma IN_BIGUNION: "IN x (BIGUNION xa) = (EX s. IN x s & IN s xa)"
-  sorry
-
-lemma BIGUNION_EMPTY: "BIGUNION EMPTY = EMPTY"
-  sorry
-
-lemma BIGUNION_SING: "BIGUNION (INSERT x EMPTY) = x"
-  sorry
-
-lemma BIGUNION_UNION: "BIGUNION (pred_set.UNION x xa) = pred_set.UNION (BIGUNION x) (BIGUNION xa)"
-  sorry
-
-lemma DISJOINT_BIGUNION: "(ALL (s::('a => bool) => bool) t::'a => bool.
-    DISJOINT (BIGUNION s) t =
-    (ALL s'::'a => bool. IN s' s --> DISJOINT s' t)) &
-(ALL (x::('a => bool) => bool) xa::'a => bool.
-    DISJOINT xa (BIGUNION x) =
-    (ALL xb::'a => bool. IN xb x --> DISJOINT xa xb))"
-  sorry
-
-lemma BIGUNION_INSERT: "BIGUNION (INSERT x xa) = pred_set.UNION x (BIGUNION xa)"
-  sorry
-
-lemma BIGUNION_SUBSET: "SUBSET (BIGUNION P) X = (ALL Y. IN Y P --> SUBSET Y X)"
-  sorry
-
-lemma FINITE_BIGUNION: "FINITE x & (ALL s. IN s x --> FINITE s) ==> FINITE (BIGUNION x)"
-  sorry
-
-definition
-  BIGINTER :: "(('a => bool) => bool) => 'a => bool"  where
-  "BIGINTER == %B. GSPEC (%x. (x, ALL P. IN P B --> IN x P))"
-
-lemma BIGINTER: "BIGINTER B = GSPEC (%x. (x, ALL P. IN P B --> IN x P))"
-  sorry
-
-lemma IN_BIGINTER: "IN x (BIGINTER B) = (ALL P. IN P B --> IN x P)"
-  sorry
-
-lemma BIGINTER_INSERT: "BIGINTER (INSERT P B) = pred_set.INTER P (BIGINTER B)"
-  sorry
-
-lemma BIGINTER_EMPTY: "BIGINTER EMPTY = pred_set.UNIV"
-  sorry
-
-lemma BIGINTER_INTER: "BIGINTER (INSERT x (INSERT xa EMPTY)) = pred_set.INTER x xa"
-  sorry
-
-lemma BIGINTER_SING: "BIGINTER (INSERT x EMPTY) = x"
-  sorry
-
-lemma SUBSET_BIGINTER: "SUBSET X (BIGINTER P) = (ALL x. IN x P --> SUBSET X x)"
-  sorry
-
-lemma DISJOINT_BIGINTER: "IN xa xb & DISJOINT xa x
-==> DISJOINT x (BIGINTER xb) & DISJOINT (BIGINTER xb) x"
-  sorry
-
-definition
-  CROSS :: "('a => bool) => ('b => bool) => 'a * 'b => bool"  where
-  "CROSS == %P Q. GSPEC (%p. (p, IN (fst p) P & IN (snd p) Q))"
-
-lemma CROSS_DEF: "CROSS P Q = GSPEC (%p. (p, IN (fst p) P & IN (snd p) Q))"
-  sorry
-
-lemma IN_CROSS: "IN xb (CROSS x xa) = (IN (fst xb) x & IN (snd xb) xa)"
-  sorry
-
-lemma CROSS_EMPTY: "CROSS x EMPTY = EMPTY & CROSS EMPTY x = EMPTY"
-  sorry
-
-lemma CROSS_INSERT_LEFT: "CROSS (INSERT xb x) xa =
-pred_set.UNION (CROSS (INSERT xb EMPTY) xa) (CROSS x xa)"
-  sorry
-
-lemma CROSS_INSERT_RIGHT: "CROSS x (INSERT xb xa) =
-pred_set.UNION (CROSS x (INSERT xb EMPTY)) (CROSS x xa)"
-  sorry
-
-lemma FINITE_CROSS: "FINITE x & FINITE xa ==> FINITE (CROSS x xa)"
-  sorry
-
-lemma CROSS_SINGS: "CROSS (INSERT x EMPTY) (INSERT xa EMPTY) = INSERT (x, xa) EMPTY"
-  sorry
-
-lemma CARD_SING_CROSS: "FINITE (s::'b => bool) ==> CARD (CROSS (INSERT (x::'a) EMPTY) s) = CARD s"
-  sorry
-
-lemma CARD_CROSS: "FINITE x & FINITE xa ==> CARD (CROSS x xa) = CARD x * CARD xa"
-  sorry
-
-lemma CROSS_SUBSET: "SUBSET (CROSS xb xc) (CROSS x xa) =
-(xb = EMPTY | xc = EMPTY | SUBSET xb x & SUBSET xc xa)"
-  sorry
-
-lemma FINITE_CROSS_EQ: "FINITE (CROSS P Q) = (P = EMPTY | Q = EMPTY | FINITE P & FINITE Q)"
-  sorry
-
-definition
-  COMPL :: "('a => bool) => 'a => bool"  where
-  "COMPL == DIFF pred_set.UNIV"
-
-lemma COMPL_DEF: "COMPL P = DIFF pred_set.UNIV P"
-  sorry
-
-lemma IN_COMPL: "IN x (COMPL xa) = (~ IN x xa)"
-  sorry
-
-lemma COMPL_COMPL: "COMPL (COMPL x) = x"
-  sorry
-
-lemma COMPL_CLAUSES: "pred_set.INTER (COMPL x) x = EMPTY &
-pred_set.UNION (COMPL x) x = pred_set.UNIV"
-  sorry
-
-lemma COMPL_SPLITS: "pred_set.UNION (pred_set.INTER x xa) (pred_set.INTER (COMPL x) xa) = xa"
-  sorry
-
-lemma INTER_UNION_COMPL: "pred_set.INTER x xa = COMPL (pred_set.UNION (COMPL x) (COMPL xa))"
-  sorry
-
-lemma COMPL_EMPTY: "COMPL EMPTY = pred_set.UNIV"
-  sorry
-
-consts
-  count :: "nat => nat => bool" 
-
-defs
-  count_primdef: "count == %n. GSPEC (%m. (m, m < n))"
-
-lemma count_def: "count n = GSPEC (%m. (m, m < n))"
-  sorry
-
-lemma IN_COUNT: "IN m (count n) = (m < n)"
-  sorry
-
-lemma COUNT_ZERO: "count 0 = EMPTY"
-  sorry
-
-lemma COUNT_SUC: "count (Suc n) = INSERT n (count n)"
-  sorry
-
-lemma FINITE_COUNT: "FINITE (count n)"
-  sorry
-
-lemma CARD_COUNT: "CARD (count n) = n"
-  sorry
-
-definition
-  ITSET_tupled :: "('a => 'b => 'b) => ('a => bool) * 'b => 'b"  where
-  "ITSET_tupled ==
-%f. WFREC
-     (SOME R.
-         WF R &
-         (ALL b s.
-             FINITE s & s ~= EMPTY --> R (REST s, f (CHOICE s) b) (s, b)))
-     (%ITSET_tupled (v, v1).
-         if FINITE v
-         then if v = EMPTY then v1
-              else ITSET_tupled (REST v, f (CHOICE v) v1)
-         else ARB)"
-
-lemma ITSET_tupled_primitive_def: "ITSET_tupled f =
-WFREC
- (SOME R.
-     WF R &
-     (ALL b s. FINITE s & s ~= EMPTY --> R (REST s, f (CHOICE s) b) (s, b)))
- (%ITSET_tupled (v, v1).
-     if FINITE v
-     then if v = EMPTY then v1 else ITSET_tupled (REST v, f (CHOICE v) v1)
-     else ARB)"
-  sorry
-
-definition
-  ITSET :: "('a => 'b => 'b) => ('a => bool) => 'b => 'b"  where
-  "ITSET == %f x x1. ITSET_tupled f (x, x1)"
-
-lemma ITSET_curried_def: "ITSET (f::'a => 'b => 'b) (x::'a => bool) (x1::'b) = ITSET_tupled f (x, x1)"
-  sorry
-
-lemma ITSET_IND: "(!!(s::'a => bool) b::'b.
-    (FINITE s & s ~= EMPTY
-     ==> (P::('a => bool) => 'b => bool) (REST s)
-          ((f::'a => 'b => 'b) (CHOICE s) b))
-    ==> P s b)
-==> P (v::'a => bool) (x::'b)"
-  sorry
-
-lemma ITSET_THM: "FINITE s
-==> ITSET f s b =
-    (if s = EMPTY then b else ITSET f (REST s) (f (CHOICE s) b))"
-  sorry
-
-lemma ITSET_EMPTY: "ITSET (x::'a => 'b => 'b) EMPTY (xa::'b) = xa"
-  sorry
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL" 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/HOL" 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) = HOL4Compat.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: "HOL4Compat.sum (SNOC x l) = HOL4Compat.sum l + x"
-  sorry
-
-lemma SUM_FOLDL: "HOL4Compat.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: "HOL4Compat.sum (l1 @ l2) = HOL4Compat.sum l1 + HOL4Compat.sum l2"
-  sorry
-
-lemma SUM_REVERSE: "HOL4Compat.sum (rev l) = HOL4Compat.sum l"
-  sorry
-
-lemma SUM_FLAT: "HOL4Compat.sum (concat l) = HOL4Compat.sum (map HOL4Compat.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/HOL" 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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/HOL4Prob.thy
--- a/src/HOL/Import/HOL/HOL4Prob.thy	Sat Mar 03 21:51:38 2012 +0100
+++ /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/HOL" 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/HOL" 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/HOL" 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/HOL" 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/HOL" 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/HOL" 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/HOL" 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/HOL" 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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/HOL4Real.thy
--- a/src/HOL/Import/HOL/HOL4Real.thy	Sat Mar 03 21:51:38 2012 +0100
+++ /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/HOL" 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/HOL" 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/HOL" 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/HOL" 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/HOL" seq
-
-consts
-  "hol4-->" :: "(nat => real) => real => bool" ("hol4-->")
-
-defs
-  "hol4-->_def": "hol4--> == %x x0. tends x x0 (mtop mr1, nat_ge)"
-
-lemma tends_num_real: "hol4--> x x0 = tends x x0 (mtop mr1, nat_ge)"
-  by (import seq tends_num_real)
-
-lemma SEQ: "hol4--> x x0 = (ALL e>0. EX N. ALL n>=N. abs (x n - x0) < e)"
-  by (import seq SEQ)
-
-lemma SEQ_CONST: "hol4--> (%x. k) k"
-  by (import seq SEQ_CONST)
-
-lemma SEQ_ADD: "hol4--> x x0 & hol4--> y y0 ==> hol4--> (%n. x n + y n) (x0 + y0)"
-  by (import seq SEQ_ADD)
-
-lemma SEQ_MUL: "hol4--> x x0 & hol4--> y y0 ==> hol4--> (%n. x n * y n) (x0 * y0)"
-  by (import seq SEQ_MUL)
-
-lemma SEQ_NEG: "hol4--> x x0 = hol4--> (%n. - x n) (- x0)"
-  by (import seq SEQ_NEG)
-
-lemma SEQ_INV: "hol4--> x x0 & x0 ~= 0 ==> hol4--> (%n. inverse (x n)) (inverse x0)"
-  by (import seq SEQ_INV)
-
-lemma SEQ_SUB: "hol4--> x x0 & hol4--> y y0 ==> hol4--> (%n. x n - y n) (x0 - y0)"
-  by (import seq SEQ_SUB)
-
-lemma SEQ_DIV: "hol4--> x x0 & hol4--> y y0 & y0 ~= 0 ==> hol4--> (%n. x n / y n) (x0 / y0)"
-  by (import seq SEQ_DIV)
-
-lemma SEQ_UNIQ: "hol4--> x x1 & hol4--> x x2 ==> x1 = x2"
-  by (import seq SEQ_UNIQ)
-
-consts
-  convergent :: "(nat => real) => bool" 
-
-defs
-  convergent_def: "seq.convergent == %f. Ex (hol4--> f)"
-
-lemma convergent: "seq.convergent f = Ex (hol4--> f)"
-  by (import seq convergent)
-
-definition
-  cauchy :: "(nat => real) => bool"  where
-  "cauchy ==
-%f. ALL e>0. EX N. ALL m n. N <= m & N <= n --> abs (f m - f n) < e"
-
-lemma cauchy: "cauchy f = (ALL e>0. EX N. ALL m n. N <= m & N <= n --> abs (f m - f n) < e)"
-  by (import seq cauchy)
-
-consts
-  lim :: "(nat => real) => real" 
-
-defs
-  lim_def: "seq.lim == %f. Eps (hol4--> f)"
-
-lemma lim: "seq.lim f = Eps (hol4--> f)"
-  by (import seq lim)
-
-lemma SEQ_LIM: "seq.convergent f = hol4--> f (seq.lim f)"
-  by (import seq SEQ_LIM)
-
-consts
-  subseq :: "(nat => nat) => bool" 
-
-defs
-  subseq_def: "seq.subseq == %f. ALL m n. m < n --> f m < f n"
-
-lemma subseq: "seq.subseq f = (ALL m n. m < n --> f m < f n)"
-  by (import seq subseq)
-
-lemma SUBSEQ_SUC: "seq.subseq f = (ALL n. f n < f (Suc n))"
-  by (import seq SUBSEQ_SUC)
-
-consts
-  mono :: "(nat => real) => bool" 
-
-defs
-  mono_def: "seq.mono ==
-%f. (ALL m n. m <= n --> f m <= f n) | (ALL m n. m <= n --> f n <= f m)"
-
-lemma mono: "seq.mono f =
-((ALL m n. m <= n --> f m <= f n) | (ALL m n. m <= n --> f n <= f m))"
-  by (import seq mono)
-
-lemma MONO_SUC: "seq.mono f = ((ALL x. f x <= f (Suc x)) | (ALL n. f (Suc n) <= f n))"
-  by (import seq MONO_SUC)
-
-lemma MAX_LEMMA: "EX k::real. ALL n<N::nat. abs ((s::nat => real) n) < k"
-  by (import seq MAX_LEMMA)
-
-lemma SEQ_BOUNDED: "bounded (mr1, nat_ge) s = (EX k. ALL n. abs (s n) < k)"
-  by (import seq SEQ_BOUNDED)
-
-lemma SEQ_BOUNDED_2: "(!!n. k <= f n & f n <= k') ==> bounded (mr1, nat_ge) f"
-  by (import seq SEQ_BOUNDED_2)
-
-lemma SEQ_CBOUNDED: "cauchy f ==> bounded (mr1, nat_ge) f"
-  by (import seq SEQ_CBOUNDED)
-
-lemma SEQ_ICONV: "bounded (mr1, nat_ge) f & (ALL m n. n <= m --> f n <= f m)
-==> seq.convergent f"
-  by (import seq SEQ_ICONV)
-
-lemma SEQ_NEG_CONV: "seq.convergent f = seq.convergent (%n. - f n)"
-  by (import seq SEQ_NEG_CONV)
-
-lemma SEQ_NEG_BOUNDED: "bounded (mr1, nat_ge) (%n. - f n) = bounded (mr1, nat_ge) f"
-  by (import seq SEQ_NEG_BOUNDED)
-
-lemma SEQ_BCONV: "bounded (mr1, nat_ge) f & seq.mono f ==> seq.convergent f"
-  by (import seq SEQ_BCONV)
-
-lemma SEQ_MONOSUB: "EX f. seq.subseq f & seq.mono (%n. s (f n))"
-  by (import seq SEQ_MONOSUB)
-
-lemma SEQ_SBOUNDED: "bounded (mr1, nat_ge) s ==> bounded (mr1, nat_ge) (%n. s (f n))"
-  by (import seq SEQ_SBOUNDED)
-
-lemma SEQ_SUBLE: "seq.subseq f ==> n <= f n"
-  by (import seq SEQ_SUBLE)
-
-lemma SEQ_DIRECT: "seq.subseq f ==> EX x>=N1. N2 <= f x"
-  by (import seq SEQ_DIRECT)
-
-lemma SEQ_CAUCHY: "cauchy f = seq.convergent f"
-  by (import seq SEQ_CAUCHY)
-
-lemma SEQ_LE: "hol4--> f l & hol4--> g m & (EX x. ALL xa>=x. f xa <= g xa) ==> l <= m"
-  by (import seq SEQ_LE)
-
-lemma SEQ_SUC: "hol4--> f l = hol4--> (%n. f (Suc n)) l"
-  by (import seq SEQ_SUC)
-
-lemma SEQ_ABS: "hol4--> (%n. abs (f n)) 0 = hol4--> f 0"
-  by (import seq SEQ_ABS)
-
-lemma SEQ_ABS_IMP: "hol4--> f l ==> hol4--> (%n. abs (f n)) (abs l)"
-  by (import seq SEQ_ABS_IMP)
-
-lemma SEQ_INV0: "(!!y. EX N. ALL n>=N. y < f n) ==> hol4--> (%n. inverse (f n)) 0"
-  by (import seq SEQ_INV0)
-
-lemma SEQ_POWER_ABS: "abs c < 1 ==> hol4--> (op ^ (abs c)) 0"
-  by (import seq SEQ_POWER_ABS)
-
-lemma SEQ_POWER: "abs c < 1 ==> hol4--> (op ^ c) 0"
-  by (import seq SEQ_POWER)
-
-lemma NEST_LEMMA: "(ALL n. f n <= f (Suc n)) & (ALL n. g (Suc n) <= g n) & (ALL n. f n <= g n)
-==> EX l m.
-       l <= m &
-       ((ALL n. f n <= l) & hol4--> f l) & (ALL n. m <= g n) & hol4--> g m"
-  by (import seq NEST_LEMMA)
-
-lemma NEST_LEMMA_UNIQ: "(ALL n. f n <= f (Suc n)) &
-(ALL n. g (Suc n) <= g n) & (ALL n. f n <= g n) & hol4--> (%n. f n - g n) 0
-==> EX x. ((ALL n. f n <= x) & hol4--> f x) &
-          (ALL n. x <= g n) & hol4--> g x"
-  by (import seq NEST_LEMMA_UNIQ)
-
-consts
-  sums :: "(nat => real) => real => bool" 
-
-defs
-  sums_def: "seq.sums == %f. hol4--> (%n. real.sum (0, n) f)"
-
-lemma sums: "seq.sums f s = hol4--> (%n. real.sum (0, n) f) s"
-  by (import seq sums)
-
-consts
-  summable :: "(nat => real) => bool" 
-
-defs
-  summable_def: "seq.summable == %f. Ex (seq.sums f)"
-
-lemma summable: "seq.summable f = Ex (seq.sums f)"
-  by (import seq summable)
-
-consts
-  suminf :: "(nat => real) => real" 
-
-defs
-  suminf_def: "seq.suminf == %f. Eps (seq.sums f)"
-
-lemma suminf: "seq.suminf f = Eps (seq.sums f)"
-  by (import seq suminf)
-
-lemma SUM_SUMMABLE: "seq.sums f l ==> seq.summable f"
-  by (import seq SUM_SUMMABLE)
-
-lemma SUMMABLE_SUM: "seq.summable f ==> seq.sums f (seq.suminf f)"
-  by (import seq SUMMABLE_SUM)
-
-lemma SUM_UNIQ: "seq.sums f x ==> x = seq.suminf f"
-  by (import seq SUM_UNIQ)
-
-lemma SER_0: "(!!m. n <= m ==> f m = 0) ==> seq.sums f (real.sum (0, n) f)"
-  by (import seq SER_0)
-
-lemma SER_POS_LE: "seq.summable f & (ALL m>=n. 0 <= f m) ==> real.sum (0, n) f <= seq.suminf f"
-  by (import seq SER_POS_LE)
-
-lemma SER_POS_LT: "seq.summable f & (ALL m>=n. 0 < f m) ==> real.sum (0, n) f < seq.suminf f"
-  by (import seq SER_POS_LT)
-
-lemma SER_GROUP: "seq.summable f & 0 < k
-==> seq.sums (%n. real.sum (n * k, k) f) (seq.suminf f)"
-  by (import seq SER_GROUP)
-
-lemma SER_PAIR: "seq.summable f ==> seq.sums (%n. real.sum (2 * n, 2) f) (seq.suminf f)"
-  by (import seq SER_PAIR)
-
-lemma SER_OFFSET: "seq.summable f
-==> seq.sums (%n. f (n + k)) (seq.suminf f - real.sum (0, k) f)"
-  by (import seq SER_OFFSET)
-
-lemma SER_POS_LT_PAIR: "seq.summable f & (ALL d. 0 < f (n + 2 * d) + f (n + (2 * d + 1)))
-==> real.sum (0, n) f < seq.suminf f"
-  by (import seq SER_POS_LT_PAIR)
-
-lemma SER_ADD: "seq.sums x x0 & seq.sums y y0 ==> seq.sums (%n. x n + y n) (x0 + y0)"
-  by (import seq SER_ADD)
-
-lemma SER_CMUL: "seq.sums x x0 ==> seq.sums (%n. c * x n) (c * x0)"
-  by (import seq SER_CMUL)
-
-lemma SER_NEG: "seq.sums x x0 ==> seq.sums (%xa. - x xa) (- x0)"
-  by (import seq SER_NEG)
-
-lemma SER_SUB: "seq.sums x x0 & seq.sums y y0 ==> seq.sums (%xa. x xa - y xa) (x0 - y0)"
-  by (import seq SER_SUB)
-
-lemma SER_CDIV: "seq.sums x x0 ==> seq.sums (%xa. x xa / c) (x0 / c)"
-  by (import seq SER_CDIV)
-
-lemma SER_CAUCHY: "seq.summable f =
-(ALL e>0. EX N. ALL m n. N <= m --> abs (real.sum (m, n) f) < e)"
-  by (import seq SER_CAUCHY)
-
-lemma SER_ZERO: "seq.summable f ==> hol4--> f 0"
-  by (import seq SER_ZERO)
-
-lemma SER_COMPAR: "(EX x. ALL xa>=x. abs (f xa) <= g xa) & seq.summable g ==> seq.summable f"
-  by (import seq SER_COMPAR)
-
-lemma SER_COMPARA: "(EX x. ALL xa>=x. abs (f xa) <= g xa) & seq.summable g
-==> seq.summable (%k. abs (f k))"
-  by (import seq SER_COMPARA)
-
-lemma SER_LE: "(ALL n. f n <= g n) & seq.summable f & seq.summable g
-==> seq.suminf f <= seq.suminf g"
-  by (import seq SER_LE)
-
-lemma SER_LE2: "(ALL n. abs (f n) <= g n) & seq.summable g
-==> seq.summable f & seq.suminf f <= seq.suminf g"
-  by (import seq SER_LE2)
-
-lemma SER_ACONV: "seq.summable (%n. abs (f n)) ==> seq.summable f"
-  by (import seq SER_ACONV)
-
-lemma SER_ABS: "seq.summable (%n. abs (f n))
-==> abs (seq.suminf f) <= seq.suminf (%n. abs (f n))"
-  by (import seq SER_ABS)
-
-lemma GP_FINITE: "x ~= 1 ==> real.sum (0, n) (op ^ x) = (x ^ n - 1) / (x - 1)"
-  by (import seq GP_FINITE)
-
-lemma GP: "abs x < 1 ==> seq.sums (op ^ x) (inverse (1 - x))"
-  by (import seq GP)
-
-lemma SER_RATIO: "c < 1 & (ALL n>=N. abs (f (Suc n)) <= c * abs (f n)) ==> seq.summable f"
-  by (import seq SER_RATIO)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL" lim
-
-definition
-  tends_real_real :: "(real => real) => real => real => bool"  where
-  "tends_real_real == %f l x0. tends f l (mtop mr1, nets.tendsto (mr1, x0))"
-
-lemma tends_real_real: "tends_real_real f l x0 = tends f l (mtop mr1, nets.tendsto (mr1, x0))"
-  by (import lim tends_real_real)
-
-lemma LIM: "tends_real_real f y0 x0 =
-(ALL e>0.
-    EX d>0.
-       ALL x. 0 < abs (x - x0) & abs (x - x0) < d --> abs (f x - y0) < e)"
-  by (import lim LIM)
-
-lemma LIM_CONST: "tends_real_real (%x. k) k x"
-  by (import lim LIM_CONST)
-
-lemma LIM_ADD: "tends_real_real f l x & tends_real_real g m x
-==> tends_real_real (%x. f x + g x) (l + m) x"
-  by (import lim LIM_ADD)
-
-lemma LIM_MUL: "tends_real_real f l x & tends_real_real g m x
-==> tends_real_real (%x. f x * g x) (l * m) x"
-  by (import lim LIM_MUL)
-
-lemma LIM_NEG: "tends_real_real f l x = tends_real_real (%x. - f x) (- l) x"
-  by (import lim LIM_NEG)
-
-lemma LIM_INV: "tends_real_real f l x & l ~= 0
-==> tends_real_real (%x. inverse (f x)) (inverse l) x"
-  by (import lim LIM_INV)
-
-lemma LIM_SUB: "tends_real_real f l x & tends_real_real g m x
-==> tends_real_real (%x. f x - g x) (l - m) x"
-  by (import lim LIM_SUB)
-
-lemma LIM_DIV: "tends_real_real f l x & tends_real_real g m x & m ~= 0
-==> tends_real_real (%x. f x / g x) (l / m) x"
-  by (import lim LIM_DIV)
-
-lemma LIM_NULL: "tends_real_real f l x = tends_real_real (%x. f x - l) 0 x"
-  by (import lim LIM_NULL)
-
-lemma LIM_X: "tends_real_real (%x. x) x0 x0"
-  by (import lim LIM_X)
-
-lemma LIM_UNIQ: "tends_real_real f l x & tends_real_real f m x ==> l = m"
-  by (import lim LIM_UNIQ)
-
-lemma LIM_EQUAL: "(!!x. x ~= x0 ==> f x = g x)
-==> tends_real_real f l x0 = tends_real_real g l x0"
-  by (import lim LIM_EQUAL)
-
-lemma LIM_TRANSFORM: "tends_real_real (%x. f x - g x) 0 x0 & tends_real_real g l x0
-==> tends_real_real f l x0"
-  by (import lim LIM_TRANSFORM)
-
-definition
-  diffl :: "(real => real) => real => real => bool"  where
-  "diffl == %f l x. tends_real_real (%h. (f (x + h) - f x) / h) l 0"
-
-lemma diffl: "diffl f l x = tends_real_real (%h. (f (x + h) - f x) / h) l 0"
-  by (import lim diffl)
-
-definition
-  contl :: "(real => real) => real => bool"  where
-  "contl == %f x. tends_real_real (%h. f (x + h)) (f x) 0"
-
-lemma contl: "contl f x = tends_real_real (%h. f (x + h)) (f x) 0"
-  by (import lim contl)
-
-consts
-  differentiable :: "(real => real) => real => bool" 
-
-defs
-  differentiable_def: "lim.differentiable == %f x. EX l. diffl f l x"
-
-lemma differentiable: "lim.differentiable f x = (EX l. diffl f l x)"
-  by (import lim differentiable)
-
-lemma DIFF_UNIQ: "diffl f l x & diffl f m x ==> l = m"
-  by (import lim DIFF_UNIQ)
-
-lemma DIFF_CONT: "diffl f l x ==> contl f x"
-  by (import lim DIFF_CONT)
-
-lemma CONTL_LIM: "contl f x = tends_real_real f (f x) x"
-  by (import lim CONTL_LIM)
-
-lemma DIFF_CARAT: "diffl f l x =
-(EX g. (ALL z. f z - f x = g z * (z - x)) & contl g x & g x = l)"
-  by (import lim DIFF_CARAT)
-
-lemma CONT_CONST: "contl (%x. k) x"
-  by (import lim CONT_CONST)
-
-lemma CONT_ADD: "contl f x & contl g x ==> contl (%x. f x + g x) x"
-  by (import lim CONT_ADD)
-
-lemma CONT_MUL: "contl f x & contl g x ==> contl (%x. f x * g x) x"
-  by (import lim CONT_MUL)
-
-lemma CONT_NEG: "contl f x ==> contl (%x. - f x) x"
-  by (import lim CONT_NEG)
-
-lemma CONT_INV: "contl f x & f x ~= 0 ==> contl (%x. inverse (f x)) x"
-  by (import lim CONT_INV)
-
-lemma CONT_SUB: "contl f x & contl g x ==> contl (%x. f x - g x) x"
-  by (import lim CONT_SUB)
-
-lemma CONT_DIV: "contl f x & contl g x & g x ~= 0 ==> contl (%x. f x / g x) x"
-  by (import lim CONT_DIV)
-
-lemma CONT_COMPOSE: "contl f x & contl g (f x) ==> contl (%x. g (f x)) x"
-  by (import lim CONT_COMPOSE)
-
-lemma IVT: "a <= b & (f a <= y & y <= f b) & (ALL x. a <= x & x <= b --> contl f x)
-==> EX x>=a. x <= b & f x = y"
-  by (import lim IVT)
-
-lemma IVT2: "a <= b & (f b <= y & y <= f a) & (ALL x. a <= x & x <= b --> contl f x)
-==> EX x>=a. x <= b & f x = y"
-  by (import lim IVT2)
-
-lemma DIFF_CONST: "diffl (%x. k) 0 x"
-  by (import lim DIFF_CONST)
-
-lemma DIFF_ADD: "diffl f l x & diffl g m x ==> diffl (%x. f x + g x) (l + m) x"
-  by (import lim DIFF_ADD)
-
-lemma DIFF_MUL: "diffl f l x & diffl g m x ==> diffl (%x. f x * g x) (l * g x + m * f x) x"
-  by (import lim DIFF_MUL)
-
-lemma DIFF_CMUL: "diffl f l x ==> diffl (%x. c * f x) (c * l) x"
-  by (import lim DIFF_CMUL)
-
-lemma DIFF_NEG: "diffl f l x ==> diffl (%x. - f x) (- l) x"
-  by (import lim DIFF_NEG)
-
-lemma DIFF_SUB: "diffl f l x & diffl g m x ==> diffl (%x. f x - g x) (l - m) x"
-  by (import lim DIFF_SUB)
-
-lemma DIFF_CHAIN: "diffl f l (g x) & diffl g m x ==> diffl (%x. f (g x)) (l * m) x"
-  by (import lim DIFF_CHAIN)
-
-lemma DIFF_X: "diffl (%x. x) 1 x"
-  by (import lim DIFF_X)
-
-lemma DIFF_POW: "diffl (%x. x ^ n) (real n * x ^ (n - 1)) x"
-  by (import lim DIFF_POW)
-
-lemma DIFF_XM1: "x ~= 0 ==> diffl inverse (- (inverse x ^ 2)) x"
-  by (import lim DIFF_XM1)
-
-lemma DIFF_INV: "diffl f l x & f x ~= 0 ==> diffl (%x. inverse (f x)) (- (l / f x ^ 2)) x"
-  by (import lim DIFF_INV)
-
-lemma DIFF_DIV: "diffl f l x & diffl g m x & g x ~= 0
-==> diffl (%x. f x / g x) ((l * g x - m * f x) / g x ^ 2) x"
-  by (import lim DIFF_DIV)
-
-lemma DIFF_SUM: "(!!r. m <= r & r < m + n ==> diffl (f r) (f' r x) x)
-==> diffl (%x. real.sum (m, n) (%n. f n x)) (real.sum (m, n) (%r. f' r x)) x"
-  by (import lim DIFF_SUM)
-
-lemma CONT_BOUNDED: "a <= b & (ALL x. a <= x & x <= b --> contl f x)
-==> EX M. ALL x. a <= x & x <= b --> f x <= M"
-  by (import lim CONT_BOUNDED)
-
-lemma CONT_HASSUP: "a <= b & (ALL x. a <= x & x <= b --> contl f x)
-==> EX M. (ALL x. a <= x & x <= b --> f x <= M) &
-          (ALL N<M. EX x>=a. x <= b & N < f x)"
-  by (import lim CONT_HASSUP)
-
-lemma CONT_ATTAINS: "a <= b & (ALL x. a <= x & x <= b --> contl f x)
-==> EX x. (ALL xa. a <= xa & xa <= b --> f xa <= x) &
-          (EX xa>=a. xa <= b & f xa = x)"
-  by (import lim CONT_ATTAINS)
-
-lemma CONT_ATTAINS2: "a <= b & (ALL x. a <= x & x <= b --> contl f x)
-==> EX x. (ALL xa. a <= xa & xa <= b --> x <= f xa) &
-          (EX xa>=a. xa <= b & f xa = x)"
-  by (import lim CONT_ATTAINS2)
-
-lemma CONT_ATTAINS_ALL: "a <= b & (ALL x. a <= x & x <= b --> contl f x)
-==> EX x M.
-       x <= M &
-       (ALL y. x <= y & y <= M --> (EX x>=a. x <= b & f x = y)) &
-       (ALL xa. a <= xa & xa <= b --> x <= f xa & f xa <= M)"
-  by (import lim CONT_ATTAINS_ALL)
-
-lemma DIFF_LINC: "diffl f l x & 0 < l ==> EX d>0. ALL h. 0 < h & h < d --> f x < f (x + h)"
-  by (import lim DIFF_LINC)
-
-lemma DIFF_LDEC: "diffl f l x & l < 0 ==> EX d>0. ALL h. 0 < h & h < d --> f x < f (x - h)"
-  by (import lim DIFF_LDEC)
-
-lemma DIFF_LMAX: "diffl f l x & (EX d>0. ALL y. abs (x - y) < d --> f y <= f x) ==> l = 0"
-  by (import lim DIFF_LMAX)
-
-lemma DIFF_LMIN: "diffl f l x & (EX d>0. ALL y. abs (x - y) < d --> f x <= f y) ==> l = 0"
-  by (import lim DIFF_LMIN)
-
-lemma DIFF_LCONST: "diffl f l x & (EX d>0. ALL y. abs (x - y) < d --> f y = f x) ==> l = 0"
-  by (import lim DIFF_LCONST)
-
-lemma ROLLE: "a < b &
-f a = f b &
-(ALL x. a <= x & x <= b --> contl f x) &
-(ALL x. a < x & x < b --> lim.differentiable f x)
-==> EX z>a. z < b & diffl f 0 z"
-  by (import lim ROLLE)
-
-lemma MVT: "a < b &
-(ALL x. a <= x & x <= b --> contl f x) &
-(ALL x. a < x & x < b --> lim.differentiable f x)
-==> EX l z. a < z & z < b & diffl f l z & f b - f a = (b - a) * l"
-  by (import lim MVT)
-
-lemma DIFF_ISCONST_END: "a < b &
-(ALL x. a <= x & x <= b --> contl f x) &
-(ALL x. a < x & x < b --> diffl f 0 x)
-==> f b = f a"
-  by (import lim DIFF_ISCONST_END)
-
-lemma DIFF_ISCONST: "[| a < b &
-   (ALL x. a <= x & x <= b --> contl f x) &
-   (ALL x. a < x & x < b --> diffl f 0 x);
-   a <= x & x <= b |]
-==> f x = f a"
-  by (import lim DIFF_ISCONST)
-
-lemma DIFF_ISCONST_ALL: "(!!x. diffl f 0 x) ==> f x = f y"
-  by (import lim DIFF_ISCONST_ALL)
-
-lemma INTERVAL_ABS: "((x::real) - (d::real) <= (z::real) & z <= x + d) = (abs (z - x) <= d)"
-  by (import lim INTERVAL_ABS)
-
-lemma CONT_INJ_LEMMA: "0 < d &
-(ALL z. abs (z - x) <= d --> g (f z) = z) &
-(ALL z. abs (z - x) <= d --> contl f z)
-==> ~ (ALL z. abs (z - x) <= d --> f z <= f x)"
-  by (import lim CONT_INJ_LEMMA)
-
-lemma CONT_INJ_LEMMA2: "0 < d &
-(ALL z. abs (z - x) <= d --> g (f z) = z) &
-(ALL z. abs (z - x) <= d --> contl f z)
-==> ~ (ALL z. abs (z - x) <= d --> f x <= f z)"
-  by (import lim CONT_INJ_LEMMA2)
-
-lemma CONT_INJ_RANGE: "0 < d &
-(ALL z. abs (z - x) <= d --> g (f z) = z) &
-(ALL z. abs (z - x) <= d --> contl f z)
-==> EX e>0. ALL y. abs (y - f x) <= e --> (EX z. abs (z - x) <= d & f z = y)"
-  by (import lim CONT_INJ_RANGE)
-
-lemma CONT_INVERSE: "0 < d &
-(ALL z. abs (z - x) <= d --> g (f z) = z) &
-(ALL z. abs (z - x) <= d --> contl f z)
-==> contl g (f x)"
-  by (import lim CONT_INVERSE)
-
-lemma DIFF_INVERSE: "0 < d &
-(ALL z. abs (z - x) <= d --> g (f z) = z) &
-(ALL z. abs (z - x) <= d --> contl f z) & diffl f l x & l ~= 0
-==> diffl g (inverse l) (f x)"
-  by (import lim DIFF_INVERSE)
-
-lemma DIFF_INVERSE_LT: "0 < d &
-(ALL z. abs (z - x) < d --> g (f z) = z) &
-(ALL z. abs (z - x) < d --> contl f z) & diffl f l x & l ~= 0
-==> diffl g (inverse l) (f x)"
-  by (import lim DIFF_INVERSE_LT)
-
-lemma INTERVAL_CLEMMA: "(a::real) < (x::real) & x < (b::real)
-==> EX d>0::real. ALL y::real. abs (y - x) <= d --> a < y & y < b"
-  by (import lim INTERVAL_CLEMMA)
-
-lemma DIFF_INVERSE_OPEN: "a < x &
-x < b &
-(ALL z. a < z & z < b --> g (f z) = z & contl f z) & diffl f l x & l ~= 0
-==> diffl g (inverse l) (f x)"
-  by (import lim DIFF_INVERSE_OPEN)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL" 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/HOL" transc
-
-consts
-  exp :: "real => real" 
-
-defs
-  exp_def: "transc.exp == %x. seq.suminf (%n. inverse (real (FACT n)) * x ^ n)"
-
-lemma exp: "transc.exp x = seq.suminf (%n. inverse (real (FACT n)) * x ^ n)"
-  by (import transc exp)
-
-consts
-  cos :: "real => real" 
-
-defs
-  cos_def: "transc.cos ==
-%x. seq.suminf
-     (%n. (if EVEN n then (- 1) ^ (n div 2) / real (FACT n) else 0) * x ^ n)"
-
-lemma cos: "transc.cos x =
-seq.suminf
- (%n. (if EVEN n then (- 1) ^ (n div 2) / real (FACT n) else 0) * x ^ n)"
-  by (import transc cos)
-
-consts
-  sin :: "real => real" 
-
-defs
-  sin_def: "transc.sin ==
-%x. seq.suminf
-     (%n. (if EVEN n then 0 else (- 1) ^ ((n - 1) div 2) / real (FACT n)) *
-          x ^ n)"
-
-lemma sin: "transc.sin x =
-seq.suminf
- (%n. (if EVEN n then 0 else (- 1) ^ ((n - 1) div 2) / real (FACT n)) *
-      x ^ n)"
-  by (import transc sin)
-
-lemma EXP_CONVERGES: "seq.sums (%n. inverse (real (FACT n)) * x ^ n) (transc.exp x)"
-  by (import transc EXP_CONVERGES)
-
-lemma SIN_CONVERGES: "seq.sums
- (%n. (if EVEN n then 0 else (- 1) ^ ((n - 1) div 2) / real (FACT n)) *
-      x ^ n)
- (transc.sin x)"
-  by (import transc SIN_CONVERGES)
-
-lemma COS_CONVERGES: "seq.sums
- (%n. (if EVEN n then (- 1) ^ (n div 2) / real (FACT n) else 0) * x ^ n)
- (transc.cos x)"
-  by (import transc COS_CONVERGES)
-
-lemma EXP_FDIFF: "powser.diffs (%n. inverse (real (FACT n))) = (%n. inverse (real (FACT n)))"
-  by (import transc EXP_FDIFF)
-
-lemma SIN_FDIFF: "powser.diffs
- (%n. if EVEN n then 0 else (- 1) ^ ((n - 1) div 2) / real (FACT n)) =
-(%n. if EVEN n then (- 1) ^ (n div 2) / real (FACT n) else 0)"
-  by (import transc SIN_FDIFF)
-
-lemma COS_FDIFF: "powser.diffs (%n. if EVEN n then (- 1) ^ (n div 2) / real (FACT n) else 0) =
-(%n. - (if EVEN n then 0 else (- 1) ^ ((n - 1) div 2) / real (FACT n)))"
-  by (import transc COS_FDIFF)
-
-lemma SIN_NEGLEMMA: "- transc.sin x =
-seq.suminf
- (%n. - ((if EVEN n then 0 else (- 1) ^ ((n - 1) div 2) / real (FACT n)) *
-         x ^ n))"
-  by (import transc SIN_NEGLEMMA)
-
-lemma DIFF_EXP: "diffl transc.exp (transc.exp x) x"
-  by (import transc DIFF_EXP)
-
-lemma DIFF_SIN: "diffl transc.sin (transc.cos x) x"
-  by (import transc DIFF_SIN)
-
-lemma DIFF_COS: "diffl transc.cos (- transc.sin x) x"
-  by (import transc DIFF_COS)
-
-lemma DIFF_COMPOSITE: "(diffl f l x & f x ~= 0 --> diffl (%x. inverse (f x)) (- (l / f x ^ 2)) x) &
-(diffl f l x & diffl g m x & g x ~= 0 -->
- diffl (%x. f x / g x) ((l * g x - m * f x) / g x ^ 2) x) &
-(diffl f l x & diffl g m x --> diffl (%x. f x + g x) (l + m) x) &
-(diffl f l x & diffl g m x -->
- diffl (%x. f x * g x) (l * g x + m * f x) x) &
-(diffl f l x & diffl g m x --> diffl (%x. f x - g x) (l - m) x) &
-(diffl f l x --> diffl (%x. - f x) (- l) x) &
-(diffl g m x --> diffl (%x. g x ^ n) (real n * g x ^ (n - 1) * m) x) &
-(diffl g m x --> diffl (%x. transc.exp (g x)) (transc.exp (g x) * m) x) &
-(diffl g m x --> diffl (%x. transc.sin (g x)) (transc.cos (g x) * m) x) &
-(diffl g m x --> diffl (%x. transc.cos (g x)) (- transc.sin (g x) * m) x)"
-  by (import transc DIFF_COMPOSITE)
-
-lemma EXP_0: "transc.exp 0 = 1"
-  by (import transc EXP_0)
-
-lemma EXP_LE_X: "0 <= x ==> 1 + x <= transc.exp x"
-  by (import transc EXP_LE_X)
-
-lemma EXP_LT_1: "0 < x ==> 1 < transc.exp x"
-  by (import transc EXP_LT_1)
-
-lemma EXP_ADD_MUL: "transc.exp (x + y) * transc.exp (- x) = transc.exp y"
-  by (import transc EXP_ADD_MUL)
-
-lemma EXP_NEG_MUL: "transc.exp x * transc.exp (- x) = 1"
-  by (import transc EXP_NEG_MUL)
-
-lemma EXP_NEG_MUL2: "transc.exp (- x) * transc.exp x = 1"
-  by (import transc EXP_NEG_MUL2)
-
-lemma EXP_NEG: "transc.exp (- x) = inverse (transc.exp x)"
-  by (import transc EXP_NEG)
-
-lemma EXP_ADD: "transc.exp (x + y) = transc.exp x * transc.exp y"
-  by (import transc EXP_ADD)
-
-lemma EXP_POS_LE: "0 <= transc.exp x"
-  by (import transc EXP_POS_LE)
-
-lemma EXP_NZ: "transc.exp x ~= 0"
-  by (import transc EXP_NZ)
-
-lemma EXP_POS_LT: "0 < transc.exp x"
-  by (import transc EXP_POS_LT)
-
-lemma EXP_N: "transc.exp (real n * x) = transc.exp x ^ n"
-  by (import transc EXP_N)
-
-lemma EXP_SUB: "transc.exp (x - y) = transc.exp x / transc.exp y"
-  by (import transc EXP_SUB)
-
-lemma EXP_MONO_IMP: "x < y ==> transc.exp x < transc.exp y"
-  by (import transc EXP_MONO_IMP)
-
-lemma EXP_MONO_LT: "(transc.exp x < transc.exp y) = (x < y)"
-  by (import transc EXP_MONO_LT)
-
-lemma EXP_MONO_LE: "(transc.exp x <= transc.exp y) = (x <= y)"
-  by (import transc EXP_MONO_LE)
-
-lemma EXP_INJ: "(transc.exp x = transc.exp y) = (x = y)"
-  by (import transc EXP_INJ)
-
-lemma EXP_TOTAL_LEMMA: "1 <= y ==> EX x>=0. x <= y - 1 & transc.exp x = y"
-  by (import transc EXP_TOTAL_LEMMA)
-
-lemma EXP_TOTAL: "0 < y ==> EX x. transc.exp x = y"
-  by (import transc EXP_TOTAL)
-
-consts
-  ln :: "real => real" 
-
-defs
-  ln_def: "transc.ln == %x. SOME u. transc.exp u = x"
-
-lemma ln: "transc.ln x = (SOME u. transc.exp u = x)"
-  by (import transc ln)
-
-lemma LN_EXP: "transc.ln (transc.exp x) = x"
-  by (import transc LN_EXP)
-
-lemma EXP_LN: "(transc.exp (transc.ln x) = x) = (0 < x)"
-  by (import transc EXP_LN)
-
-lemma LN_MUL: "0 < x & 0 < y ==> transc.ln (x * y) = transc.ln x + transc.ln y"
-  by (import transc LN_MUL)
-
-lemma LN_INJ: "0 < x & 0 < y ==> (transc.ln x = transc.ln y) = (x = y)"
-  by (import transc LN_INJ)
-
-lemma LN_1: "transc.ln 1 = 0"
-  by (import transc LN_1)
-
-lemma LN_INV: "0 < x ==> transc.ln (inverse x) = - transc.ln x"
-  by (import transc LN_INV)
-
-lemma LN_DIV: "0 < x & 0 < y ==> transc.ln (x / y) = transc.ln x - transc.ln y"
-  by (import transc LN_DIV)
-
-lemma LN_MONO_LT: "0 < x & 0 < y ==> (transc.ln x < transc.ln y) = (x < y)"
-  by (import transc LN_MONO_LT)
-
-lemma LN_MONO_LE: "0 < x & 0 < y ==> (transc.ln x <= transc.ln y) = (x <= y)"
-  by (import transc LN_MONO_LE)
-
-lemma LN_POW: "0 < x ==> transc.ln (x ^ n) = real n * transc.ln x"
-  by (import transc LN_POW)
-
-lemma LN_LE: "0 <= x ==> transc.ln (1 + x) <= x"
-  by (import transc LN_LE)
-
-lemma LN_LT_X: "0 < x ==> transc.ln x < x"
-  by (import transc LN_LT_X)
-
-lemma LN_POS: "1 <= x ==> 0 <= transc.ln x"
-  by (import transc LN_POS)
-
-consts
-  root :: "nat => real => real" 
-
-defs
-  root_def: "transc.root == %n x. SOME u. (0 < x --> 0 < u) & u ^ n = x"
-
-lemma root: "transc.root n x = (SOME u. (0 < x --> 0 < u) & u ^ n = x)"
-  by (import transc root)
-
-consts
-  sqrt :: "real => real" 
-
-defs
-  sqrt_def: "transc.sqrt == transc.root 2"
-
-lemma sqrt: "transc.sqrt x = transc.root 2 x"
-  by (import transc sqrt)
-
-lemma ROOT_LT_LEMMA: "0 < x ==> transc.exp (transc.ln x / real (Suc n)) ^ Suc n = x"
-  by (import transc ROOT_LT_LEMMA)
-
-lemma ROOT_LN: "0 < x ==> transc.root (Suc n) x = transc.exp (transc.ln x / real (Suc n))"
-  by (import transc ROOT_LN)
-
-lemma ROOT_0: "transc.root (Suc n) 0 = 0"
-  by (import transc ROOT_0)
-
-lemma ROOT_1: "transc.root (Suc n) 1 = 1"
-  by (import transc ROOT_1)
-
-lemma ROOT_POS_LT: "0 < x ==> 0 < transc.root (Suc n) x"
-  by (import transc ROOT_POS_LT)
-
-lemma ROOT_POW_POS: "0 <= x ==> transc.root (Suc n) x ^ Suc n = x"
-  by (import transc ROOT_POW_POS)
-
-lemma POW_ROOT_POS: "0 <= x ==> transc.root (Suc n) (x ^ Suc n) = x"
-  by (import transc POW_ROOT_POS)
-
-lemma ROOT_POS: "0 <= x ==> 0 <= transc.root (Suc n) x"
-  by (import transc ROOT_POS)
-
-lemma ROOT_POS_UNIQ: "0 <= x & 0 <= y & y ^ Suc n = x ==> transc.root (Suc n) x = y"
-  by (import transc ROOT_POS_UNIQ)
-
-lemma ROOT_MUL: "0 <= x & 0 <= y
-==> transc.root (Suc n) (x * y) =
-    transc.root (Suc n) x * transc.root (Suc n) y"
-  by (import transc ROOT_MUL)
-
-lemma ROOT_INV: "0 <= x ==> transc.root (Suc n) (inverse x) = inverse (transc.root (Suc n) x)"
-  by (import transc ROOT_INV)
-
-lemma ROOT_DIV: "0 <= xa & 0 <= xb
-==> transc.root (Suc x) (xa / xb) =
-    transc.root (Suc x) xa / transc.root (Suc x) xb"
-  by (import transc ROOT_DIV)
-
-lemma ROOT_MONO_LE: "0 <= x & x <= y ==> transc.root (Suc n) x <= transc.root (Suc n) y"
-  by (import transc ROOT_MONO_LE)
-
-lemma SQRT_0: "transc.sqrt 0 = 0"
-  by (import transc SQRT_0)
-
-lemma SQRT_1: "transc.sqrt 1 = 1"
-  by (import transc SQRT_1)
-
-lemma SQRT_POS_LT: "0 < x ==> 0 < transc.sqrt x"
-  by (import transc SQRT_POS_LT)
-
-lemma SQRT_POS_LE: "0 <= x ==> 0 <= transc.sqrt x"
-  by (import transc SQRT_POS_LE)
-
-lemma SQRT_POW2: "(transc.sqrt x ^ 2 = x) = (0 <= x)"
-  by (import transc SQRT_POW2)
-
-lemma SQRT_POW_2: "0 <= x ==> transc.sqrt x ^ 2 = x"
-  by (import transc SQRT_POW_2)
-
-lemma POW_2_SQRT: "0 <= x ==> transc.sqrt (x ^ 2) = x"
-  by (import transc POW_2_SQRT)
-
-lemma SQRT_POS_UNIQ: "0 <= x & 0 <= xa & xa ^ 2 = x ==> transc.sqrt x = xa"
-  by (import transc SQRT_POS_UNIQ)
-
-lemma SQRT_MUL: "0 <= x & 0 <= xa ==> transc.sqrt (x * xa) = transc.sqrt x * transc.sqrt xa"
-  by (import transc SQRT_MUL)
-
-lemma SQRT_INV: "0 <= x ==> transc.sqrt (inverse x) = inverse (transc.sqrt x)"
-  by (import transc SQRT_INV)
-
-lemma SQRT_DIV: "0 <= x & 0 <= xa ==> transc.sqrt (x / xa) = transc.sqrt x / transc.sqrt xa"
-  by (import transc SQRT_DIV)
-
-lemma SQRT_MONO_LE: "0 <= x & x <= xa ==> transc.sqrt x <= transc.sqrt xa"
-  by (import transc SQRT_MONO_LE)
-
-lemma SQRT_EVEN_POW2: "EVEN n ==> transc.sqrt (2 ^ n) = 2 ^ (n div 2)"
-  by (import transc SQRT_EVEN_POW2)
-
-lemma REAL_DIV_SQRT: "0 <= x ==> x / transc.sqrt x = transc.sqrt x"
-  by (import transc REAL_DIV_SQRT)
-
-lemma SQRT_EQ: "x ^ 2 = y & 0 <= x ==> x = transc.sqrt y"
-  by (import transc SQRT_EQ)
-
-lemma SIN_0: "transc.sin 0 = 0"
-  by (import transc SIN_0)
-
-lemma COS_0: "transc.cos 0 = 1"
-  by (import transc COS_0)
-
-lemma SIN_CIRCLE: "transc.sin x ^ 2 + transc.cos x ^ 2 = 1"
-  by (import transc SIN_CIRCLE)
-
-lemma SIN_BOUND: "abs (transc.sin x) <= 1"
-  by (import transc SIN_BOUND)
-
-lemma SIN_BOUNDS: "- 1 <= transc.sin x & transc.sin x <= 1"
-  by (import transc SIN_BOUNDS)
-
-lemma COS_BOUND: "abs (transc.cos x) <= 1"
-  by (import transc COS_BOUND)
-
-lemma COS_BOUNDS: "- 1 <= transc.cos x & transc.cos x <= 1"
-  by (import transc COS_BOUNDS)
-
-lemma SIN_COS_ADD: "(transc.sin (x + y) -
- (transc.sin x * transc.cos y + transc.cos x * transc.sin y)) ^
-2 +
-(transc.cos (x + y) -
- (transc.cos x * transc.cos y - transc.sin x * transc.sin y)) ^
-2 =
-0"
-  by (import transc SIN_COS_ADD)
-
-lemma SIN_COS_NEG: "(transc.sin (- x) + transc.sin x) ^ 2 +
-(transc.cos (- x) - transc.cos x) ^ 2 =
-0"
-  by (import transc SIN_COS_NEG)
-
-lemma SIN_ADD: "transc.sin (x + y) =
-transc.sin x * transc.cos y + transc.cos x * transc.sin y"
-  by (import transc SIN_ADD)
-
-lemma COS_ADD: "transc.cos (x + y) =
-transc.cos x * transc.cos y - transc.sin x * transc.sin y"
-  by (import transc COS_ADD)
-
-lemma SIN_NEG: "transc.sin (- x) = - transc.sin x"
-  by (import transc SIN_NEG)
-
-lemma COS_NEG: "transc.cos (- x) = transc.cos x"
-  by (import transc COS_NEG)
-
-lemma SIN_DOUBLE: "transc.sin (2 * x) = 2 * (transc.sin x * transc.cos x)"
-  by (import transc SIN_DOUBLE)
-
-lemma COS_DOUBLE: "transc.cos (2 * x) = transc.cos x ^ 2 - transc.sin x ^ 2"
-  by (import transc COS_DOUBLE)
-
-lemma SIN_PAIRED: "seq.sums (%n. (- 1) ^ n / real (FACT (2 * n + 1)) * x ^ (2 * n + 1))
- (transc.sin x)"
-  by (import transc SIN_PAIRED)
-
-lemma SIN_POS: "0 < x & x < 2 ==> 0 < transc.sin x"
-  by (import transc SIN_POS)
-
-lemma COS_PAIRED: "seq.sums (%n. (- 1) ^ n / real (FACT (2 * n)) * x ^ (2 * n)) (transc.cos x)"
-  by (import transc COS_PAIRED)
-
-lemma COS_2: "transc.cos 2 < 0"
-  by (import transc COS_2)
-
-lemma COS_ISZERO: "EX! x. 0 <= x & x <= 2 & transc.cos x = 0"
-  by (import transc COS_ISZERO)
-
-consts
-  pi :: "real" 
-
-defs
-  pi_def: "transc.pi == 2 * (SOME x. 0 <= x & x <= 2 & transc.cos x = 0)"
-
-lemma pi: "transc.pi = 2 * (SOME x. 0 <= x & x <= 2 & transc.cos x = 0)"
-  by (import transc pi)
-
-lemma PI2: "transc.pi / 2 = (SOME x. 0 <= x & x <= 2 & transc.cos x = 0)"
-  by (import transc PI2)
-
-lemma COS_PI2: "transc.cos (transc.pi / 2) = 0"
-  by (import transc COS_PI2)
-
-lemma PI2_BOUNDS: "0 < transc.pi / 2 & transc.pi / 2 < 2"
-  by (import transc PI2_BOUNDS)
-
-lemma PI_POS: "0 < transc.pi"
-  by (import transc PI_POS)
-
-lemma SIN_PI2: "transc.sin (transc.pi / 2) = 1"
-  by (import transc SIN_PI2)
-
-lemma COS_PI: "transc.cos transc.pi = - 1"
-  by (import transc COS_PI)
-
-lemma SIN_PI: "transc.sin transc.pi = 0"
-  by (import transc SIN_PI)
-
-lemma SIN_COS: "transc.sin x = transc.cos (transc.pi / 2 - x)"
-  by (import transc SIN_COS)
-
-lemma COS_SIN: "transc.cos x = transc.sin (transc.pi / 2 - x)"
-  by (import transc COS_SIN)
-
-lemma SIN_PERIODIC_PI: "transc.sin (x + transc.pi) = - transc.sin x"
-  by (import transc SIN_PERIODIC_PI)
-
-lemma COS_PERIODIC_PI: "transc.cos (x + transc.pi) = - transc.cos x"
-  by (import transc COS_PERIODIC_PI)
-
-lemma SIN_PERIODIC: "transc.sin (x + 2 * transc.pi) = transc.sin x"
-  by (import transc SIN_PERIODIC)
-
-lemma COS_PERIODIC: "transc.cos (x + 2 * transc.pi) = transc.cos x"
-  by (import transc COS_PERIODIC)
-
-lemma COS_NPI: "transc.cos (real n * transc.pi) = (- 1) ^ n"
-  by (import transc COS_NPI)
-
-lemma SIN_NPI: "transc.sin (real (n::nat) * transc.pi) = (0::real)"
-  by (import transc SIN_NPI)
-
-lemma SIN_POS_PI2: "0 < x & x < transc.pi / 2 ==> 0 < transc.sin x"
-  by (import transc SIN_POS_PI2)
-
-lemma COS_POS_PI2: "0 < x & x < transc.pi / 2 ==> 0 < transc.cos x"
-  by (import transc COS_POS_PI2)
-
-lemma COS_POS_PI: "- (transc.pi / 2) < x & x < transc.pi / 2 ==> 0 < transc.cos x"
-  by (import transc COS_POS_PI)
-
-lemma SIN_POS_PI: "0 < x & x < transc.pi ==> 0 < transc.sin x"
-  by (import transc SIN_POS_PI)
-
-lemma COS_POS_PI2_LE: "0 <= x & x <= transc.pi / 2 ==> 0 <= transc.cos x"
-  by (import transc COS_POS_PI2_LE)
-
-lemma COS_POS_PI_LE: "- (transc.pi / 2) <= x & x <= transc.pi / 2 ==> 0 <= transc.cos x"
-  by (import transc COS_POS_PI_LE)
-
-lemma SIN_POS_PI2_LE: "0 <= x & x <= transc.pi / 2 ==> 0 <= transc.sin x"
-  by (import transc SIN_POS_PI2_LE)
-
-lemma SIN_POS_PI_LE: "0 <= x & x <= transc.pi ==> 0 <= transc.sin x"
-  by (import transc SIN_POS_PI_LE)
-
-lemma COS_TOTAL: "- 1 <= y & y <= 1 ==> EX! x. 0 <= x & x <= transc.pi & transc.cos x = y"
-  by (import transc COS_TOTAL)
-
-lemma SIN_TOTAL: "- 1 <= y & y <= 1
-==> EX! x. - (transc.pi / 2) <= x & x <= transc.pi / 2 & transc.sin x = y"
-  by (import transc SIN_TOTAL)
-
-lemma COS_ZERO_LEMMA: "0 <= x & transc.cos x = 0 ==> EX n. ~ EVEN n & x = real n * (transc.pi / 2)"
-  by (import transc COS_ZERO_LEMMA)
-
-lemma SIN_ZERO_LEMMA: "0 <= x & transc.sin x = 0 ==> EX n. EVEN n & x = real n * (transc.pi / 2)"
-  by (import transc SIN_ZERO_LEMMA)
-
-lemma COS_ZERO: "(transc.cos x = 0) =
-((EX n. ~ EVEN n & x = real n * (transc.pi / 2)) |
- (EX n. ~ EVEN n & x = - (real n * (transc.pi / 2))))"
-  by (import transc COS_ZERO)
-
-lemma SIN_ZERO: "(transc.sin x = 0) =
-((EX n. EVEN n & x = real n * (transc.pi / 2)) |
- (EX n. EVEN n & x = - (real n * (transc.pi / 2))))"
-  by (import transc SIN_ZERO)
-
-consts
-  tan :: "real => real" 
-
-defs
-  tan_def: "transc.tan == %x. transc.sin x / transc.cos x"
-
-lemma tan: "transc.tan x = transc.sin x / transc.cos x"
-  by (import transc tan)
-
-lemma TAN_0: "transc.tan 0 = 0"
-  by (import transc TAN_0)
-
-lemma TAN_PI: "transc.tan transc.pi = 0"
-  by (import transc TAN_PI)
-
-lemma TAN_NPI: "transc.tan (real (n::nat) * transc.pi) = (0::real)"
-  by (import transc TAN_NPI)
-
-lemma TAN_NEG: "transc.tan (- x) = - transc.tan x"
-  by (import transc TAN_NEG)
-
-lemma TAN_PERIODIC: "transc.tan (x + 2 * transc.pi) = transc.tan x"
-  by (import transc TAN_PERIODIC)
-
-lemma TAN_ADD: "transc.cos x ~= 0 & transc.cos y ~= 0 & transc.cos (x + y) ~= 0
-==> transc.tan (x + y) =
-    (transc.tan x + transc.tan y) / (1 - transc.tan x * transc.tan y)"
-  by (import transc TAN_ADD)
-
-lemma TAN_DOUBLE: "transc.cos x ~= 0 & transc.cos (2 * x) ~= 0
-==> transc.tan (2 * x) = 2 * transc.tan x / (1 - transc.tan x ^ 2)"
-  by (import transc TAN_DOUBLE)
-
-lemma TAN_POS_PI2: "0 < x & x < transc.pi / 2 ==> 0 < transc.tan x"
-  by (import transc TAN_POS_PI2)
-
-lemma DIFF_TAN: "transc.cos x ~= 0 ==> diffl transc.tan (inverse (transc.cos x ^ 2)) x"
-  by (import transc DIFF_TAN)
-
-lemma TAN_TOTAL_LEMMA: "0 < y ==> EX x>0. x < transc.pi / 2 & y < transc.tan x"
-  by (import transc TAN_TOTAL_LEMMA)
-
-lemma TAN_TOTAL_POS: "0 <= y ==> EX x>=0. x < transc.pi / 2 & transc.tan x = y"
-  by (import transc TAN_TOTAL_POS)
-
-lemma TAN_TOTAL: "EX! x. - (transc.pi / 2) < x & x < transc.pi / 2 & transc.tan x = y"
-  by (import transc TAN_TOTAL)
-
-definition
-  asn :: "real => real"  where
-  "asn ==
-%y. SOME x. - (transc.pi / 2) <= x & x <= transc.pi / 2 & transc.sin x = y"
-
-lemma asn: "asn y =
-(SOME x. - (transc.pi / 2) <= x & x <= transc.pi / 2 & transc.sin x = y)"
-  by (import transc asn)
-
-definition
-  acs :: "real => real"  where
-  "acs == %y. SOME x. 0 <= x & x <= transc.pi & transc.cos x = y"
-
-lemma acs: "acs y = (SOME x. 0 <= x & x <= transc.pi & transc.cos x = y)"
-  by (import transc acs)
-
-definition
-  atn :: "real => real"  where
-  "atn ==
-%y. SOME x. - (transc.pi / 2) < x & x < transc.pi / 2 & transc.tan x = y"
-
-lemma atn: "atn y =
-(SOME x. - (transc.pi / 2) < x & x < transc.pi / 2 & transc.tan x = y)"
-  by (import transc atn)
-
-lemma ASN: "- 1 <= y & y <= 1
-==> - (transc.pi / 2) <= asn y &
-    asn y <= transc.pi / 2 & transc.sin (asn y) = y"
-  by (import transc ASN)
-
-lemma ASN_SIN: "- 1 <= y & y <= 1 ==> transc.sin (asn y) = y"
-  by (import transc ASN_SIN)
-
-lemma ASN_BOUNDS: "- 1 <= y & y <= 1 ==> - (transc.pi / 2) <= asn y & asn y <= transc.pi / 2"
-  by (import transc ASN_BOUNDS)
-
-lemma ASN_BOUNDS_LT: "- 1 < y & y < 1 ==> - (transc.pi / 2) < asn y & asn y < transc.pi / 2"
-  by (import transc ASN_BOUNDS_LT)
-
-lemma SIN_ASN: "- (transc.pi / 2) <= x & x <= transc.pi / 2 ==> asn (transc.sin x) = x"
-  by (import transc SIN_ASN)
-
-lemma ACS: "- 1 <= y & y <= 1
-==> 0 <= acs y & acs y <= transc.pi & transc.cos (acs y) = y"
-  by (import transc ACS)
-
-lemma ACS_COS: "- 1 <= y & y <= 1 ==> transc.cos (acs y) = y"
-  by (import transc ACS_COS)
-
-lemma ACS_BOUNDS: "- 1 <= y & y <= 1 ==> 0 <= acs y & acs y <= transc.pi"
-  by (import transc ACS_BOUNDS)
-
-lemma ACS_BOUNDS_LT: "- 1 < y & y < 1 ==> 0 < acs y & acs y < transc.pi"
-  by (import transc ACS_BOUNDS_LT)
-
-lemma COS_ACS: "0 <= x & x <= transc.pi ==> acs (transc.cos x) = x"
-  by (import transc COS_ACS)
-
-lemma ATN: "- (transc.pi / 2) < atn y & atn y < transc.pi / 2 & transc.tan (atn y) = y"
-  by (import transc ATN)
-
-lemma ATN_TAN: "transc.tan (atn x) = x"
-  by (import transc ATN_TAN)
-
-lemma ATN_BOUNDS: "- (transc.pi / 2) < atn x & atn x < transc.pi / 2"
-  by (import transc ATN_BOUNDS)
-
-lemma TAN_ATN: "- (transc.pi / 2) < x & x < transc.pi / 2 ==> atn (transc.tan x) = x"
-  by (import transc TAN_ATN)
-
-lemma TAN_SEC: "transc.cos x ~= 0 ==> 1 + transc.tan x ^ 2 = inverse (transc.cos x) ^ 2"
-  by (import transc TAN_SEC)
-
-lemma SIN_COS_SQ: "0 <= x & x <= transc.pi
-==> transc.sin x = transc.sqrt (1 - transc.cos x ^ 2)"
-  by (import transc SIN_COS_SQ)
-
-lemma COS_SIN_SQ: "- (transc.pi / 2) <= x & x <= transc.pi / 2
-==> transc.cos x = transc.sqrt (1 - transc.sin x ^ 2)"
-  by (import transc COS_SIN_SQ)
-
-lemma COS_ATN_NZ: "transc.cos (atn x) ~= 0"
-  by (import transc COS_ATN_NZ)
-
-lemma COS_ASN_NZ: "- 1 < x & x < 1 ==> transc.cos (asn x) ~= 0"
-  by (import transc COS_ASN_NZ)
-
-lemma SIN_ACS_NZ: "- 1 < x & x < 1 ==> transc.sin (acs x) ~= 0"
-  by (import transc SIN_ACS_NZ)
-
-lemma COS_SIN_SQRT: "0 <= transc.cos x ==> transc.cos x = transc.sqrt (1 - transc.sin x ^ 2)"
-  by (import transc COS_SIN_SQRT)
-
-lemma SIN_COS_SQRT: "0 <= transc.sin x ==> transc.sin x = transc.sqrt (1 - transc.cos x ^ 2)"
-  by (import transc SIN_COS_SQRT)
-
-lemma DIFF_LN: "0 < x ==> diffl transc.ln (inverse x) x"
-  by (import transc DIFF_LN)
-
-lemma DIFF_ASN_LEMMA: "- 1 < x & x < 1 ==> diffl asn (inverse (transc.cos (asn x))) x"
-  by (import transc DIFF_ASN_LEMMA)
-
-lemma DIFF_ASN: "- 1 < x & x < 1 ==> diffl asn (inverse (transc.sqrt (1 - x ^ 2))) x"
-  by (import transc DIFF_ASN)
-
-lemma DIFF_ACS_LEMMA: "- 1 < x & x < 1 ==> diffl acs (inverse (- transc.sin (acs x))) x"
-  by (import transc DIFF_ACS_LEMMA)
-
-lemma DIFF_ACS: "- 1 < x & x < 1 ==> diffl acs (- inverse (transc.sqrt (1 - x ^ 2))) x"
-  by (import transc DIFF_ACS)
-
-lemma DIFF_ATN: "diffl atn (inverse (1 + x ^ 2)) x"
-  by (import transc DIFF_ATN)
-
-definition
-  division :: "real * real => (nat => real) => bool"  where
-  "division ==
-%(a, b) D.
-   D 0 = a & (EX N. (ALL n<N. D n < D (Suc n)) & (ALL n>=N. D n = b))"
-
-lemma division: "division (a, b) D =
-(D 0 = a & (EX N. (ALL n<N. D n < D (Suc n)) & (ALL n>=N. D n = b)))"
-  by (import transc division)
-
-definition
-  dsize :: "(nat => real) => nat"  where
-  "dsize == %D. SOME N. (ALL n<N. D n < D (Suc n)) & (ALL n>=N. D n = D N)"
-
-lemma dsize: "dsize D = (SOME N. (ALL n<N. D n < D (Suc n)) & (ALL n>=N. D n = D N))"
-  by (import transc dsize)
-
-definition
-  tdiv :: "real * real => (nat => real) * (nat => real) => bool"  where
-  "tdiv ==
-%(a, b) (D, p). division (a, b) D & (ALL n. D n <= p n & p n <= D (Suc n))"
-
-lemma tdiv: "tdiv (a, b) (D, p) =
-(division (a, b) D & (ALL n. D n <= p n & p n <= D (Suc n)))"
-  by (import transc tdiv)
-
-definition
-  gauge :: "(real => bool) => (real => real) => bool"  where
-  "gauge == %E g. ALL x. E x --> 0 < g x"
-
-lemma gauge: "gauge E g = (ALL x. E x --> 0 < g x)"
-  by (import transc gauge)
-
-definition
-  fine :: "(real => real) => (nat => real) * (nat => real) => bool"  where
-  "fine == %g (D, p). ALL n<dsize D. D (Suc n) - D n < g (p n)"
-
-lemma fine: "fine g (D, p) = (ALL n<dsize D. D (Suc n) - D n < g (p n))"
-  by (import transc fine)
-
-definition
-  rsum :: "(nat => real) * (nat => real) => (real => real) => real"  where
-  "rsum == %(D, p) f. real.sum (0, dsize D) (%n. f (p n) * (D (Suc n) - D n))"
-
-lemma rsum: "rsum (D, p) f = real.sum (0, dsize D) (%n. f (p n) * (D (Suc n) - D n))"
-  by (import transc rsum)
-
-definition
-  Dint :: "real * real => (real => real) => real => bool"  where
-  "Dint ==
-%(a, b) f k.
-   ALL e>0.
-      EX g. gauge (%x. a <= x & x <= b) g &
-            (ALL D p.
-                tdiv (a, b) (D, p) & fine g (D, p) -->
-                abs (rsum (D, p) f - k) < e)"
-
-lemma Dint: "Dint (a, b) f k =
-(ALL e>0.
-    EX g. gauge (%x. a <= x & x <= b) g &
-          (ALL D p.
-              tdiv (a, b) (D, p) & fine g (D, p) -->
-              abs (rsum (D, p) f - k) < e))"
-  by (import transc Dint)
-
-lemma DIVISION_0: "a = b ==> dsize (%n. if n = 0 then a else b) = 0"
-  by (import transc DIVISION_0)
-
-lemma DIVISION_1: "a < b ==> dsize (%n. if n = 0 then a else b) = 1"
-  by (import transc DIVISION_1)
-
-lemma DIVISION_SINGLE: "a <= b ==> division (a, b) (%n. if n = 0 then a else b)"
-  by (import transc DIVISION_SINGLE)
-
-lemma DIVISION_LHS: "division (a, b) D ==> D 0 = a"
-  by (import transc DIVISION_LHS)
-
-lemma DIVISION_THM: "division (a, b) D =
-(D 0 = a & (ALL n<dsize D. D n < D (Suc n)) & (ALL n>=dsize D. D n = b))"
-  by (import transc DIVISION_THM)
-
-lemma DIVISION_RHS: "division (a, b) D ==> D (dsize D) = b"
-  by (import transc DIVISION_RHS)
-
-lemma DIVISION_LT_GEN: "division (a, b) D & m < n & n <= dsize D ==> D m < D n"
-  by (import transc DIVISION_LT_GEN)
-
-lemma DIVISION_LT: "[| division (a, b) D; n < dsize D |] ==> D 0 < D (Suc n)"
-  by (import transc DIVISION_LT)
-
-lemma DIVISION_LE: "division (a, b) D ==> a <= b"
-  by (import transc DIVISION_LE)
-
-lemma DIVISION_GT: "[| division (a, b) D; n < dsize D |] ==> D n < D (dsize D)"
-  by (import transc DIVISION_GT)
-
-lemma DIVISION_EQ: "division (a, b) D ==> (a = b) = (dsize D = 0)"
-  by (import transc DIVISION_EQ)
-
-lemma DIVISION_LBOUND: "division (a, b) D ==> a <= D r"
-  by (import transc DIVISION_LBOUND)
-
-lemma DIVISION_LBOUND_LT: "division (a, b) D & dsize D ~= 0 ==> a < D (Suc n)"
-  by (import transc DIVISION_LBOUND_LT)
-
-lemma DIVISION_UBOUND: "division (a, b) D ==> D r <= b"
-  by (import transc DIVISION_UBOUND)
-
-lemma DIVISION_UBOUND_LT: "division (a, b) D & n < dsize D ==> D n < b"
-  by (import transc DIVISION_UBOUND_LT)
-
-lemma DIVISION_APPEND: "(EX D1 p1. tdiv (a, b) (D1, p1) & fine g (D1, p1)) &
-(EX D2 p2. tdiv (b, c) (D2, p2) & fine g (D2, p2))
-==> EX x p. tdiv (a, c) (x, p) & fine g (x, p)"
-  by (import transc DIVISION_APPEND)
-
-lemma DIVISION_EXISTS: "a <= b & gauge (%x. a <= x & x <= b) g
-==> EX D p. tdiv (a, b) (D, p) & fine g (D, p)"
-  by (import transc DIVISION_EXISTS)
-
-lemma GAUGE_MIN: "gauge E g1 & gauge E g2 ==> gauge E (%x. if g1 x < g2 x then g1 x else g2 x)"
-  by (import transc GAUGE_MIN)
-
-lemma FINE_MIN: "fine (%x. if g1 x < g2 x then g1 x else g2 x) (D, p)
-==> fine g1 (D, p) & fine g2 (D, p)"
-  by (import transc FINE_MIN)
-
-lemma DINT_UNIQ: "a <= b & Dint (a, b) f k1 & Dint (a, b) f k2 ==> k1 = k2"
-  by (import transc DINT_UNIQ)
-
-lemma INTEGRAL_NULL: "Dint (a, a) f 0"
-  by (import transc INTEGRAL_NULL)
-
-lemma FTC1: "a <= b & (ALL x. a <= x & x <= b --> diffl f (f' x) x)
-==> Dint (a, b) f' (f b - f a)"
-  by (import transc FTC1)
-
-lemma MCLAURIN: "0 < h &
-0 < n &
-diff 0 = f &
-(ALL m t. m < n & 0 <= t & t <= h --> diffl (diff m) (diff (Suc m) t) t)
-==> EX t>0.
-       t < h &
-       f h =
-       real.sum (0, n) (%m. diff m 0 / real (FACT m) * h ^ m) +
-       diff n t / real (FACT n) * h ^ n"
-  by (import transc MCLAURIN)
-
-lemma MCLAURIN_NEG: "h < 0 &
-0 < n &
-diff 0 = f &
-(ALL m t. m < n & h <= t & t <= 0 --> diffl (diff m) (diff (Suc m) t) t)
-==> EX t>h.
-       t < 0 &
-       f h =
-       real.sum (0, n) (%m. diff m 0 / real (FACT m) * h ^ m) +
-       diff n t / real (FACT n) * h ^ n"
-  by (import transc MCLAURIN_NEG)
-
-lemma MCLAURIN_ALL_LT: "[| diff 0 = f & (ALL m x. diffl (diff m) (diff (Suc m) x) x);
-   x ~= 0 & 0 < n |]
-==> EX t. 0 < abs t &
-          abs t < abs x &
-          f x =
-          real.sum (0, n) (%m. diff m 0 / real (FACT m) * x ^ m) +
-          diff n t / real (FACT n) * x ^ n"
-  by (import transc MCLAURIN_ALL_LT)
-
-lemma MCLAURIN_ZERO: "(x::real) = (0::real) & (0::nat) < (n::nat)
-==> real.sum (0::nat, n)
-     (%m::nat.
-         (diff::nat => real => real) m (0::real) / real (FACT m) * x ^ m) =
-    diff (0::nat) (0::real)"
-  by (import transc MCLAURIN_ZERO)
-
-lemma MCLAURIN_ALL_LE: "diff 0 = f & (ALL m x. diffl (diff m) (diff (Suc m) x) x)
-==> EX t. abs t <= abs x &
-          f x =
-          real.sum (0, n) (%m. diff m 0 / real (FACT m) * x ^ m) +
-          diff n t / real (FACT n) * x ^ n"
-  by (import transc MCLAURIN_ALL_LE)
-
-lemma MCLAURIN_EXP_LT: "x ~= 0 & 0 < n
-==> EX xa.
-       0 < abs xa &
-       abs xa < abs x &
-       transc.exp x =
-       real.sum (0, n) (%m. x ^ m / real (FACT m)) +
-       transc.exp xa / real (FACT n) * x ^ n"
-  by (import transc MCLAURIN_EXP_LT)
-
-lemma MCLAURIN_EXP_LE: "EX xa.
-   abs xa <= abs x &
-   transc.exp x =
-   real.sum (0, n) (%m. x ^ m / real (FACT m)) +
-   transc.exp xa / real (FACT n) * x ^ n"
-  by (import transc MCLAURIN_EXP_LE)
-
-lemma DIFF_LN_COMPOSITE: "diffl g m x & 0 < g x ==> diffl (%x. transc.ln (g x)) (inverse (g x) * m) x"
-  by (import transc DIFF_LN_COMPOSITE)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL" poly
-
-consts
-  poly :: "real list => real => real" 
-
-specification (poly_primdef: poly) poly_def: "(ALL x. poly [] x = 0) & (ALL h t x. poly (h # t) x = h + x * poly t x)"
-  by (import poly poly_def)
-
-consts
-  poly_add :: "real list => real list => real list" 
-
-specification (poly_add_primdef: poly_add) poly_add_def: "(ALL l2. poly_add [] l2 = l2) &
-(ALL h t l2.
-    poly_add (h # t) l2 =
-    (if l2 = [] then h # t else (h + hd l2) # poly_add t (tl l2)))"
-  by (import poly poly_add_def)
-
-consts
-  "##" :: "real => real list => real list" ("##")
-
-specification ("##") poly_cmul_def: "(ALL c. ## c [] = []) & (ALL c h t. ## c (h # t) = c * h # ## c t)"
-  by (import poly poly_cmul_def)
-
-consts
-  poly_neg :: "real list => real list" 
-
-defs
-  poly_neg_primdef: "poly_neg == ## (- 1)"
-
-lemma poly_neg_def: "poly_neg = ## (- 1)"
-  by (import poly poly_neg_def)
-
-consts
-  poly_mul :: "real list => real list => real list" 
-
-specification (poly_mul_primdef: poly_mul) poly_mul_def: "(ALL l2. poly_mul [] l2 = []) &
-(ALL h t l2.
-    poly_mul (h # t) l2 =
-    (if t = [] then ## h l2 else poly_add (## h l2) (0 # poly_mul t l2)))"
-  by (import poly poly_mul_def)
-
-consts
-  poly_exp :: "real list => nat => real list" 
-
-specification (poly_exp_primdef: poly_exp) poly_exp_def: "(ALL p. poly_exp p 0 = [1]) &
-(ALL p n. poly_exp p (Suc n) = poly_mul p (poly_exp p n))"
-  by (import poly poly_exp_def)
-
-consts
-  poly_diff_aux :: "nat => real list => real list" 
-
-specification (poly_diff_aux_primdef: poly_diff_aux) poly_diff_aux_def: "(ALL n. poly_diff_aux n [] = []) &
-(ALL n h t. poly_diff_aux n (h # t) = real n * h # poly_diff_aux (Suc n) t)"
-  by (import poly poly_diff_aux_def)
-
-definition
-  diff :: "real list => real list"  where
-  "diff == %l. if l = [] then [] else poly_diff_aux 1 (tl l)"
-
-lemma poly_diff_def: "diff l = (if l = [] then [] else poly_diff_aux 1 (tl l))"
-  by (import poly poly_diff_def)
-
-lemma POLY_ADD_CLAUSES: "poly_add [] p2 = p2 &
-poly_add p1 [] = p1 &
-poly_add (h1 # t1) (h2 # t2) = (h1 + h2) # poly_add t1 t2"
-  by (import poly POLY_ADD_CLAUSES)
-
-lemma POLY_CMUL_CLAUSES: "## c [] = [] & ## c (h # t) = c * h # ## c t"
-  by (import poly POLY_CMUL_CLAUSES)
-
-lemma POLY_NEG_CLAUSES: "poly_neg [] = [] & poly_neg (h # t) = - h # poly_neg t"
-  by (import poly POLY_NEG_CLAUSES)
-
-lemma POLY_MUL_CLAUSES: "poly_mul [] p2 = [] &
-poly_mul [h1] p2 = ## h1 p2 &
-poly_mul (h1 # k1 # t1) p2 = poly_add (## h1 p2) (0 # poly_mul (k1 # t1) p2)"
-  by (import poly POLY_MUL_CLAUSES)
-
-lemma POLY_DIFF_CLAUSES: "diff [] = [] & diff [c] = [] & diff (h # t) = poly_diff_aux 1 t"
-  by (import poly POLY_DIFF_CLAUSES)
-
-lemma POLY_ADD: "poly (poly_add t p2) x = poly t x + poly p2 x"
-  by (import poly POLY_ADD)
-
-lemma POLY_CMUL: "poly (## c t) x = c * poly t x"
-  by (import poly POLY_CMUL)
-
-lemma POLY_NEG: "poly (poly_neg x) xa = - poly x xa"
-  by (import poly POLY_NEG)
-
-lemma POLY_MUL: "poly (poly_mul t p2) x = poly t x * poly p2 x"
-  by (import poly POLY_MUL)
-
-lemma POLY_EXP: "poly (poly_exp p n) x = poly p x ^ n"
-  by (import poly POLY_EXP)
-
-lemma POLY_DIFF_LEMMA: "diffl (%x. x ^ Suc n * poly t x) (x ^ n * poly (poly_diff_aux (Suc n) t) x)
- x"
-  by (import poly POLY_DIFF_LEMMA)
-
-lemma POLY_DIFF: "diffl (poly t) (poly (diff t) x) x"
-  by (import poly POLY_DIFF)
-
-lemma POLY_DIFFERENTIABLE: "lim.differentiable (poly l) x"
-  by (import poly POLY_DIFFERENTIABLE)
-
-lemma POLY_CONT: "contl (poly l) x"
-  by (import poly POLY_CONT)
-
-lemma POLY_IVT_POS: "xa < xb & poly x xa < 0 & 0 < poly x xb
-==> EX xc>xa. xc < xb & poly x xc = 0"
-  by (import poly POLY_IVT_POS)
-
-lemma POLY_IVT_NEG: "a < b & 0 < poly p a & poly p b < 0 ==> EX x>a. x < b & poly p x = 0"
-  by (import poly POLY_IVT_NEG)
-
-lemma POLY_MVT: "a < b ==> EX x>a. x < b & poly p b - poly p a = (b - a) * poly (diff p) x"
-  by (import poly POLY_MVT)
-
-lemma POLY_ADD_RZERO: "poly (poly_add x []) = poly x"
-  by (import poly POLY_ADD_RZERO)
-
-lemma POLY_MUL_ASSOC: "poly (poly_mul x (poly_mul xa xb)) = poly (poly_mul (poly_mul x xa) xb)"
-  by (import poly POLY_MUL_ASSOC)
-
-lemma POLY_EXP_ADD: "poly (poly_exp xb (xa + x)) =
-poly (poly_mul (poly_exp xb xa) (poly_exp xb x))"
-  by (import poly POLY_EXP_ADD)
-
-lemma POLY_DIFF_AUX_ADD: "poly (poly_diff_aux n (poly_add t p2)) =
-poly (poly_add (poly_diff_aux n t) (poly_diff_aux n p2))"
-  by (import poly POLY_DIFF_AUX_ADD)
-
-lemma POLY_DIFF_AUX_CMUL: "poly (poly_diff_aux n (## c t)) = poly (## c (poly_diff_aux n t))"
-  by (import poly POLY_DIFF_AUX_CMUL)
-
-lemma POLY_DIFF_AUX_NEG: "poly (poly_diff_aux xa (poly_neg x)) = poly (poly_neg (poly_diff_aux xa x))"
-  by (import poly POLY_DIFF_AUX_NEG)
-
-lemma POLY_DIFF_AUX_MUL_LEMMA: "poly (poly_diff_aux (Suc n) t) = poly (poly_add (poly_diff_aux n t) t)"
-  by (import poly POLY_DIFF_AUX_MUL_LEMMA)
-
-lemma POLY_DIFF_ADD: "poly (diff (poly_add t p2)) = poly (poly_add (diff t) (diff p2))"
-  by (import poly POLY_DIFF_ADD)
-
-lemma POLY_DIFF_CMUL: "poly (diff (## c t)) = poly (## c (diff t))"
-  by (import poly POLY_DIFF_CMUL)
-
-lemma POLY_DIFF_NEG: "poly (diff (poly_neg x)) = poly (poly_neg (diff x))"
-  by (import poly POLY_DIFF_NEG)
-
-lemma POLY_DIFF_MUL_LEMMA: "poly (diff (xa # x)) = poly (poly_add (0 # diff x) x)"
-  by (import poly POLY_DIFF_MUL_LEMMA)
-
-lemma POLY_DIFF_MUL: "poly (diff (poly_mul t p2)) =
-poly (poly_add (poly_mul t (diff p2)) (poly_mul (diff t) p2))"
-  by (import poly POLY_DIFF_MUL)
-
-lemma POLY_DIFF_EXP: "poly (diff (poly_exp p (Suc n))) =
-poly (poly_mul (## (real (Suc n)) (poly_exp p n)) (diff p))"
-  by (import poly POLY_DIFF_EXP)
-
-lemma POLY_DIFF_EXP_PRIME: "poly (diff (poly_exp [- a, 1] (Suc n))) =
-poly (## (real (Suc n)) (poly_exp [- a, 1] n))"
-  by (import poly POLY_DIFF_EXP_PRIME)
-
-lemma POLY_LINEAR_REM: "EX q r. h # t = poly_add [r] (poly_mul [- a, 1] q)"
-  by (import poly POLY_LINEAR_REM)
-
-lemma POLY_LINEAR_DIVIDES: "(poly t a = 0) = (t = [] | (EX q. t = poly_mul [- a, 1] q))"
-  by (import poly POLY_LINEAR_DIVIDES)
-
-lemma POLY_LENGTH_MUL: "length (poly_mul [- a, 1] x) = Suc (length x)"
-  by (import poly POLY_LENGTH_MUL)
-
-lemma POLY_ROOTS_INDEX_LEMMA: "poly p ~= poly [] & length p = n
-==> EX i. ALL x. poly p x = 0 --> (EX m<=n. x = i m)"
-  by (import poly POLY_ROOTS_INDEX_LEMMA)
-
-lemma POLY_ROOTS_INDEX_LENGTH: "poly p ~= poly []
-==> EX i. ALL x. poly p x = 0 --> (EX n<=length p. x = i n)"
-  by (import poly POLY_ROOTS_INDEX_LENGTH)
-
-lemma POLY_ROOTS_FINITE_LEMMA: "poly (p::real list) ~= poly []
-==> EX (N::nat) i::nat => real.
-       ALL x::real. poly p x = (0::real) --> (EX n<N. x = i n)"
-  by (import poly POLY_ROOTS_FINITE_LEMMA)
-
-lemma FINITE_LEMMA: "(!!xb::real. (xa::real => bool) xb ==> EX n<x::nat. xb = (i::nat => real) n)
-==> EX a::real. ALL x::real. xa x --> x < a"
-  by (import poly FINITE_LEMMA)
-
-lemma POLY_ROOTS_FINITE: "(poly (p::real list) ~= poly []) =
-(EX (N::nat) i::nat => real.
-    ALL x::real. poly p x = (0::real) --> (EX n<N. x = i n))"
-  by (import poly POLY_ROOTS_FINITE)
-
-lemma POLY_ENTIRE_LEMMA: "poly p ~= poly [] & poly q ~= poly [] ==> poly (poly_mul p q) ~= poly []"
-  by (import poly POLY_ENTIRE_LEMMA)
-
-lemma POLY_ENTIRE: "(poly (poly_mul p q) = poly []) = (poly p = poly [] | poly q = poly [])"
-  by (import poly POLY_ENTIRE)
-
-lemma POLY_MUL_LCANCEL: "(poly (poly_mul x xa) = poly (poly_mul x xb)) =
-(poly x = poly [] | poly xa = poly xb)"
-  by (import poly POLY_MUL_LCANCEL)
-
-lemma POLY_EXP_EQ_0: "(poly (poly_exp p n) = poly []) = (poly p = poly [] & n ~= 0)"
-  by (import poly POLY_EXP_EQ_0)
-
-lemma POLY_PRIME_EQ_0: "poly [a, 1] ~= poly []"
-  by (import poly POLY_PRIME_EQ_0)
-
-lemma POLY_EXP_PRIME_EQ_0: "poly (poly_exp [a, 1] n) ~= poly []"
-  by (import poly POLY_EXP_PRIME_EQ_0)
-
-lemma POLY_ZERO_LEMMA: "poly (h # t) = poly [] ==> h = 0 & poly t = poly []"
-  by (import poly POLY_ZERO_LEMMA)
-
-lemma POLY_ZERO: "(poly t = poly []) = list_all (%c. c = 0) t"
-  by (import poly POLY_ZERO)
-
-lemma POLY_DIFF_AUX_ISZERO: "list_all (%c. c = 0) (poly_diff_aux (Suc n) t) = list_all (%c. c = 0) t"
-  by (import poly POLY_DIFF_AUX_ISZERO)
-
-lemma POLY_DIFF_ISZERO: "poly (diff x) = poly [] ==> EX h. poly x = poly [h]"
-  by (import poly POLY_DIFF_ISZERO)
-
-lemma POLY_DIFF_ZERO: "poly x = poly [] ==> poly (diff x) = poly []"
-  by (import poly POLY_DIFF_ZERO)
-
-lemma POLY_DIFF_WELLDEF: "poly p = poly q ==> poly (diff p) = poly (diff q)"
-  by (import poly POLY_DIFF_WELLDEF)
-
-definition
-  poly_divides :: "real list => real list => bool"  where
-  "poly_divides == %p1 p2. EX q. poly p2 = poly (poly_mul p1 q)"
-
-lemma poly_divides: "poly_divides p1 p2 = (EX q. poly p2 = poly (poly_mul p1 q))"
-  by (import poly poly_divides)
-
-lemma POLY_PRIMES: "poly_divides [a, 1] (poly_mul p q) =
-(poly_divides [a, 1] p | poly_divides [a, 1] q)"
-  by (import poly POLY_PRIMES)
-
-lemma POLY_DIVIDES_REFL: "poly_divides p p"
-  by (import poly POLY_DIVIDES_REFL)
-
-lemma POLY_DIVIDES_TRANS: "poly_divides p q & poly_divides q r ==> poly_divides p r"
-  by (import poly POLY_DIVIDES_TRANS)
-
-lemma POLY_DIVIDES_EXP: "m <= n ==> poly_divides (poly_exp p m) (poly_exp p n)"
-  by (import poly POLY_DIVIDES_EXP)
-
-lemma POLY_EXP_DIVIDES: "poly_divides (poly_exp p n) q & m <= n ==> poly_divides (poly_exp p m) q"
-  by (import poly POLY_EXP_DIVIDES)
-
-lemma POLY_DIVIDES_ADD: "poly_divides p q & poly_divides p r ==> poly_divides p (poly_add q r)"
-  by (import poly POLY_DIVIDES_ADD)
-
-lemma POLY_DIVIDES_SUB: "poly_divides p q & poly_divides p (poly_add q r) ==> poly_divides p r"
-  by (import poly POLY_DIVIDES_SUB)
-
-lemma POLY_DIVIDES_SUB2: "poly_divides p r & poly_divides p (poly_add q r) ==> poly_divides p q"
-  by (import poly POLY_DIVIDES_SUB2)
-
-lemma POLY_DIVIDES_ZERO: "poly p = poly [] ==> poly_divides q p"
-  by (import poly POLY_DIVIDES_ZERO)
-
-lemma POLY_ORDER_EXISTS: "length p = d & poly p ~= poly []
-==> EX x. poly_divides (poly_exp [- a, 1] x) p &
-          ~ poly_divides (poly_exp [- a, 1] (Suc x)) p"
-  by (import poly POLY_ORDER_EXISTS)
-
-lemma POLY_ORDER: "poly p ~= poly []
-==> EX! n.
-       poly_divides (poly_exp [- a, 1] n) p &
-       ~ poly_divides (poly_exp [- a, 1] (Suc n)) p"
-  by (import poly POLY_ORDER)
-
-definition
-  poly_order :: "real => real list => nat"  where
-  "poly_order ==
-%a p. SOME n.
-         poly_divides (poly_exp [- a, 1] n) p &
-         ~ poly_divides (poly_exp [- a, 1] (Suc n)) p"
-
-lemma poly_order: "poly_order a p =
-(SOME n.
-    poly_divides (poly_exp [- a, 1] n) p &
-    ~ poly_divides (poly_exp [- a, 1] (Suc n)) p)"
-  by (import poly poly_order)
-
-lemma ORDER: "(poly_divides (poly_exp [- a, 1] n) p &
- ~ poly_divides (poly_exp [- a, 1] (Suc n)) p) =
-(n = poly_order a p & poly p ~= poly [])"
-  by (import poly ORDER)
-
-lemma ORDER_THM: "poly p ~= poly []
-==> poly_divides (poly_exp [- a, 1] (poly_order a p)) p &
-    ~ poly_divides (poly_exp [- a, 1] (Suc (poly_order a p))) p"
-  by (import poly ORDER_THM)
-
-lemma ORDER_UNIQUE: "poly p ~= poly [] &
-poly_divides (poly_exp [- a, 1] n) p &
-~ poly_divides (poly_exp [- a, 1] (Suc n)) p
-==> n = poly_order a p"
-  by (import poly ORDER_UNIQUE)
-
-lemma ORDER_POLY: "poly p = poly q ==> poly_order a p = poly_order a q"
-  by (import poly ORDER_POLY)
-
-lemma ORDER_ROOT: "(poly p a = 0) = (poly p = poly [] | poly_order a p ~= 0)"
-  by (import poly ORDER_ROOT)
-
-lemma ORDER_DIVIDES: "poly_divides (poly_exp [- a, 1] n) p =
-(poly p = poly [] | n <= poly_order a p)"
-  by (import poly ORDER_DIVIDES)
-
-lemma ORDER_DECOMP: "poly p ~= poly []
-==> EX x. poly p = poly (poly_mul (poly_exp [- a, 1] (poly_order a p)) x) &
-          ~ poly_divides [- a, 1] x"
-  by (import poly ORDER_DECOMP)
-
-lemma ORDER_MUL: "poly (poly_mul p q) ~= poly []
-==> poly_order a (poly_mul p q) = poly_order a p + poly_order a q"
-  by (import poly ORDER_MUL)
-
-lemma ORDER_DIFF: "poly (diff p) ~= poly [] & poly_order a p ~= 0
-==> poly_order a p = Suc (poly_order a (diff p))"
-  by (import poly ORDER_DIFF)
-
-lemma POLY_SQUAREFREE_DECOMP_ORDER: "poly (diff p) ~= poly [] &
-poly p = poly (poly_mul q d) &
-poly (diff p) = poly (poly_mul e d) &
-poly d = poly (poly_add (poly_mul r p) (poly_mul s (diff p)))
-==> poly_order a q = (if poly_order a p = 0 then 0 else 1)"
-  by (import poly POLY_SQUAREFREE_DECOMP_ORDER)
-
-definition
-  rsquarefree :: "real list => bool"  where
-  "rsquarefree ==
-%p. poly p ~= poly [] & (ALL a. poly_order a p = 0 | poly_order a p = 1)"
-
-lemma rsquarefree: "rsquarefree p =
-(poly p ~= poly [] & (ALL a. poly_order a p = 0 | poly_order a p = 1))"
-  by (import poly rsquarefree)
-
-lemma RSQUAREFREE_ROOTS: "rsquarefree p = (ALL a. ~ (poly p a = 0 & poly (diff p) a = 0))"
-  by (import poly RSQUAREFREE_ROOTS)
-
-lemma RSQUAREFREE_DECOMP: "rsquarefree p & poly p a = 0
-==> EX q. poly p = poly (poly_mul [- a, 1] q) & poly q a ~= 0"
-  by (import poly RSQUAREFREE_DECOMP)
-
-lemma POLY_SQUAREFREE_DECOMP: "poly (diff p) ~= poly [] &
-poly p = poly (poly_mul q d) &
-poly (diff p) = poly (poly_mul e d) &
-poly d = poly (poly_add (poly_mul r p) (poly_mul s (diff p)))
-==> rsquarefree q & (ALL x. (poly q x = 0) = (poly p x = 0))"
-  by (import poly POLY_SQUAREFREE_DECOMP)
-
-consts
-  normalize :: "real list => real list" 
-
-specification (normalize) normalize: "normalize [] = [] &
-(ALL h t.
-    normalize (h # t) =
-    (if normalize t = [] then if h = 0 then [] else [h]
-     else h # normalize t))"
-  by (import poly normalize)
-
-lemma POLY_NORMALIZE: "poly (normalize t) = poly t"
-  by (import poly POLY_NORMALIZE)
-
-definition
-  degree :: "real list => nat"  where
-  "degree == %p. PRE (length (normalize p))"
-
-lemma degree: "degree p = PRE (length (normalize p))"
-  by (import poly degree)
-
-lemma DEGREE_ZERO: "poly p = poly [] ==> degree p = 0"
-  by (import poly DEGREE_ZERO)
-
-lemma POLY_ROOTS_FINITE_SET: "poly p ~= poly [] ==> FINITE (GSPEC (%x. (x, poly p x = 0)))"
-  by (import poly POLY_ROOTS_FINITE_SET)
-
-lemma POLY_MONO: "abs x <= k ==> abs (poly xa x) <= poly (map abs xa) k"
-  by (import poly POLY_MONO)
-
-;end_setup
-
-end
-
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/HOL4Vec.thy
--- a/src/HOL/Import/HOL/HOL4Vec.thy	Sat Mar 03 21:51:38 2012 +0100
+++ /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/HOL" 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/HOL" 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 + HOL4Compat.list_size f a"
-  by (import word_base word_size_def)
-
-lemma word_11: "(WORD a = WORD a') = (a = a')"
-  by (import word_base word_11)
-
-lemma word_case_cong: "M = M' & (ALL a. M' = WORD a --> f a = f' a)
-==> word_base.word_case f M = word_base.word_case f' M'"
-  by (import word_base word_case_cong)
-
-lemma word_nchotomy: "EX l. x = WORD l"
-  by (import word_base word_nchotomy)
-
-lemma word_Axiom: "EX fn. ALL a. fn (WORD a) = f a"
-  by (import word_base word_Axiom)
-
-lemma word_induction: "(!!a. P (WORD a)) ==> P x"
-  by (import word_base word_induction)
-
-lemma word_Ax: "EX fn. ALL a. fn (WORD a) = f a"
-  by (import word_base word_Ax)
-
-lemma WORD_11: "(WORD x = WORD xa) = (x = xa)"
-  by (import word_base WORD_11)
-
-lemma word_induct: "(!!l. x (WORD l)) ==> x xa"
-  by (import word_base word_induct)
-
-lemma word_cases: "EX l. x = WORD l"
-  by (import word_base word_cases)
-
-consts
-  WORDLEN :: "'a word => nat" 
-
-specification (WORDLEN) WORDLEN_DEF: "ALL l. WORDLEN (WORD l) = length l"
-  by (import word_base WORDLEN_DEF)
-
-consts
-  PWORDLEN :: "nat => 'a word => bool" 
-
-defs
-  PWORDLEN_primdef: "PWORDLEN == %n. GSPEC (%w. (w, WORDLEN w = n))"
-
-lemma PWORDLEN_def: "PWORDLEN n = GSPEC (%w. (w, WORDLEN w = n))"
-  by (import word_base PWORDLEN_def)
-
-lemma IN_PWORDLEN: "IN (WORD l) (PWORDLEN n) = (length l = n)"
-  by (import word_base IN_PWORDLEN)
-
-lemma PWORDLEN: "IN w (PWORDLEN n) = (WORDLEN w = n)"
-  by (import word_base PWORDLEN)
-
-lemma PWORDLEN0: "IN w (PWORDLEN 0) ==> w = WORD []"
-  by (import word_base PWORDLEN0)
-
-lemma PWORDLEN1: "IN (WORD [x]) (PWORDLEN 1)"
-  by (import word_base PWORDLEN1)
-
-consts
-  WSEG :: "nat => nat => 'a word => 'a word" 
-
-specification (WSEG) WSEG_DEF: "ALL m k l. WSEG m k (WORD l) = WORD (LASTN m (BUTLASTN k l))"
-  by (import word_base WSEG_DEF)
-
-lemma WSEG0: "WSEG 0 k w = WORD []"
-  by (import word_base WSEG0)
-
-lemma WSEG_PWORDLEN: "RES_FORALL (PWORDLEN n)
- (%w. ALL m k. m + k <= n --> IN (WSEG m k w) (PWORDLEN m))"
-  by (import word_base WSEG_PWORDLEN)
-
-lemma WSEG_WORDLEN: "RES_FORALL (PWORDLEN x)
- (%xa. ALL xb xc. xb + xc <= x --> WORDLEN (WSEG xb xc xa) = xb)"
-  by (import word_base WSEG_WORDLEN)
-
-lemma WSEG_WORD_LENGTH: "RES_FORALL (PWORDLEN n) (%w. WSEG n 0 w = w)"
-  by (import word_base WSEG_WORD_LENGTH)
-
-consts
-  bit :: "nat => 'a word => 'a" 
-
-specification (bit) BIT_DEF: "ALL k l. bit k (WORD l) = ELL k l"
-  by (import word_base BIT_DEF)
-
-lemma BIT0: "bit 0 (WORD [x]) = x"
-  by (import word_base BIT0)
-
-lemma WSEG_BIT: "RES_FORALL (PWORDLEN n) (%w. ALL k<n. WSEG 1 k w = WORD [bit k w])"
-  by (import word_base WSEG_BIT)
-
-lemma BIT_WSEG: "RES_FORALL (PWORDLEN n)
- (%w. ALL m k j.
-         m + k <= n --> j < m --> bit j (WSEG m k w) = bit (j + k) w)"
-  by (import word_base BIT_WSEG)
-
-consts
-  MSB :: "'a word => 'a" 
-
-specification (MSB) MSB_DEF: "ALL l. MSB (WORD l) = hd l"
-  by (import word_base MSB_DEF)
-
-lemma MSB: "RES_FORALL (PWORDLEN n) (%w. 0 < n --> MSB w = bit (PRE n) w)"
-  by (import word_base MSB)
-
-consts
-  LSB :: "'a word => 'a" 
-
-specification (LSB) LSB_DEF: "ALL l. LSB (WORD l) = last l"
-  by (import word_base LSB_DEF)
-
-lemma LSB: "RES_FORALL (PWORDLEN n) (%w. 0 < n --> LSB w = bit 0 w)"
-  by (import word_base LSB)
-
-consts
-  WSPLIT :: "nat => 'a word => 'a word * 'a word" 
-
-specification (WSPLIT) WSPLIT_DEF: "ALL m l. WSPLIT m (WORD l) = (WORD (BUTLASTN m l), WORD (LASTN m l))"
-  by (import word_base WSPLIT_DEF)
-
-consts
-  WCAT :: "'a word * 'a word => 'a word" 
-
-specification (WCAT) WCAT_DEF: "ALL l1 l2. WCAT (WORD l1, WORD l2) = WORD (l1 @ l2)"
-  by (import word_base WCAT_DEF)
-
-lemma WORD_PARTITION: "(ALL n::nat.
-    RES_FORALL (PWORDLEN n)
-     (%w::'a word. ALL m<=n. WCAT (WSPLIT m w) = w)) &
-(ALL (n::nat) m::nat.
-    RES_FORALL (PWORDLEN n)
-     (%w1::'a word.
-         RES_FORALL (PWORDLEN m)
-          (%w2::'a word. WSPLIT m (WCAT (w1, w2)) = (w1, w2))))"
-  by (import word_base WORD_PARTITION)
-
-lemma WCAT_ASSOC: "WCAT (w1, WCAT (w2, w3)) = WCAT (WCAT (w1, w2), w3)"
-  by (import word_base WCAT_ASSOC)
-
-lemma WCAT0: "WCAT (WORD [], w) = w & WCAT (w, WORD []) = w"
-  by (import word_base WCAT0)
-
-lemma WCAT_11: "RES_FORALL (PWORDLEN m)
- (%wm1. RES_FORALL (PWORDLEN m)
-         (%wm2. RES_FORALL (PWORDLEN n)
-                 (%wn1. RES_FORALL (PWORDLEN n)
-                         (%wn2. (WCAT (wm1, wn1) = WCAT (wm2, wn2)) =
-                                (wm1 = wm2 & wn1 = wn2)))))"
-  by (import word_base WCAT_11)
-
-lemma WSPLIT_PWORDLEN: "RES_FORALL (PWORDLEN n)
- (%w. ALL m<=n.
-         IN (fst (WSPLIT m w)) (PWORDLEN (n - m)) &
-         IN (snd (WSPLIT m w)) (PWORDLEN m))"
-  by (import word_base WSPLIT_PWORDLEN)
-
-lemma WCAT_PWORDLEN: "RES_FORALL (PWORDLEN n1)
- (%w1. ALL n2.
-          RES_FORALL (PWORDLEN n2)
-           (%w2. IN (WCAT (w1, w2)) (PWORDLEN (n1 + n2))))"
-  by (import word_base WCAT_PWORDLEN)
-
-lemma WORDLEN_SUC_WCAT: "IN w (PWORDLEN (Suc n))
-==> RES_EXISTS (PWORDLEN 1)
-     (%b. RES_EXISTS (PWORDLEN n) (%w'. w = WCAT (b, w')))"
-  by (import word_base WORDLEN_SUC_WCAT)
-
-lemma WSEG_WSEG: "RES_FORALL (PWORDLEN n)
- (%w. ALL m1 k1 m2 k2.
-         m1 + k1 <= n & m2 + k2 <= m1 -->
-         WSEG m2 k2 (WSEG m1 k1 w) = WSEG m2 (k1 + k2) w)"
-  by (import word_base WSEG_WSEG)
-
-lemma WSPLIT_WSEG: "RES_FORALL (PWORDLEN n)
- (%w. ALL k<=n. WSPLIT k w = (WSEG (n - k) k w, WSEG k 0 w))"
-  by (import word_base WSPLIT_WSEG)
-
-lemma WSPLIT_WSEG1: "RES_FORALL (PWORDLEN n) (%w. ALL k<=n. fst (WSPLIT k w) = WSEG (n - k) k w)"
-  by (import word_base WSPLIT_WSEG1)
-
-lemma WSPLIT_WSEG2: "RES_FORALL (PWORDLEN n) (%w. ALL k<=n. snd (WSPLIT k w) = WSEG k 0 w)"
-  by (import word_base WSPLIT_WSEG2)
-
-lemma WCAT_WSEG_WSEG: "RES_FORALL (PWORDLEN n)
- (%w. ALL m1 m2 k.
-         m1 + (m2 + k) <= n -->
-         WCAT (WSEG m2 (m1 + k) w, WSEG m1 k w) = WSEG (m1 + m2) k w)"
-  by (import word_base WCAT_WSEG_WSEG)
-
-lemma WORD_SPLIT: "RES_FORALL (PWORDLEN (x + xa)) (%w. w = WCAT (WSEG x xa w, WSEG xa 0 w))"
-  by (import word_base WORD_SPLIT)
-
-lemma WORDLEN_SUC_WCAT_WSEG_WSEG: "RES_FORALL (PWORDLEN (Suc n)) (%w. w = WCAT (WSEG 1 n w, WSEG n 0 w))"
-  by (import word_base WORDLEN_SUC_WCAT_WSEG_WSEG)
-
-lemma WORDLEN_SUC_WCAT_WSEG_WSEG_RIGHT: "RES_FORALL (PWORDLEN (Suc n)) (%w. w = WCAT (WSEG n 1 w, WSEG 1 0 w))"
-  by (import word_base WORDLEN_SUC_WCAT_WSEG_WSEG_RIGHT)
-
-lemma WORDLEN_SUC_WCAT_BIT_WSEG: "RES_FORALL (PWORDLEN (Suc n)) (%w. w = WCAT (WORD [bit n w], WSEG n 0 w))"
-  by (import word_base WORDLEN_SUC_WCAT_BIT_WSEG)
-
-lemma WORDLEN_SUC_WCAT_BIT_WSEG_RIGHT: "RES_FORALL (PWORDLEN (Suc n)) (%w. w = WCAT (WSEG n 1 w, WORD [bit 0 w]))"
-  by (import word_base WORDLEN_SUC_WCAT_BIT_WSEG_RIGHT)
-
-lemma WSEG_WCAT1: "RES_FORALL (PWORDLEN n1)
- (%w1. RES_FORALL (PWORDLEN n2) (%w2. WSEG n1 n2 (WCAT (w1, w2)) = w1))"
-  by (import word_base WSEG_WCAT1)
-
-lemma WSEG_WCAT2: "RES_FORALL (PWORDLEN n1)
- (%w1. RES_FORALL (PWORDLEN n2) (%w2. WSEG n2 0 (WCAT (w1, w2)) = w2))"
-  by (import word_base WSEG_WCAT2)
-
-lemma WSEG_SUC: "RES_FORALL (PWORDLEN n)
- (%w. ALL k m1.
-         k + Suc m1 < n -->
-         WSEG (Suc m1) k w = WCAT (WSEG 1 (k + m1) w, WSEG m1 k w))"
-  by (import word_base WSEG_SUC)
-
-lemma WORD_CONS_WCAT: "WORD (x # l) = WCAT (WORD [x], WORD l)"
-  by (import word_base WORD_CONS_WCAT)
-
-lemma WORD_SNOC_WCAT: "WORD (SNOC x l) = WCAT (WORD l, WORD [x])"
-  by (import word_base WORD_SNOC_WCAT)
-
-lemma BIT_WCAT_FST: "RES_FORALL (PWORDLEN n1)
- (%w1. RES_FORALL (PWORDLEN n2)
-        (%w2. ALL k.
-                 n2 <= k & k < n1 + n2 -->
-                 bit k (WCAT (w1, w2)) = bit (k - n2) w1))"
-  by (import word_base BIT_WCAT_FST)
-
-lemma BIT_WCAT_SND: "RES_FORALL (PWORDLEN n1)
- (%w1. RES_FORALL (PWORDLEN n2)
-        (%w2. ALL k<n2. bit k (WCAT (w1, w2)) = bit k w2))"
-  by (import word_base BIT_WCAT_SND)
-
-lemma BIT_WCAT1: "RES_FORALL (PWORDLEN n) (%w. ALL b. bit n (WCAT (WORD [b], w)) = b)"
-  by (import word_base BIT_WCAT1)
-
-lemma WSEG_WCAT_WSEG1: "RES_FORALL (PWORDLEN n1)
- (%w1. RES_FORALL (PWORDLEN n2)
-        (%w2. ALL m k.
-                 m <= n1 & n2 <= k -->
-                 WSEG m k (WCAT (w1, w2)) = WSEG m (k - n2) w1))"
-  by (import word_base WSEG_WCAT_WSEG1)
-
-lemma WSEG_WCAT_WSEG2: "RES_FORALL (PWORDLEN n1)
- (%w1. RES_FORALL (PWORDLEN n2)
-        (%w2. ALL m k.
-                 m + k <= n2 --> WSEG m k (WCAT (w1, w2)) = WSEG m k w2))"
-  by (import word_base WSEG_WCAT_WSEG2)
-
-lemma WSEG_WCAT_WSEG: "RES_FORALL (PWORDLEN n1)
- (%w1. RES_FORALL (PWORDLEN n2)
-        (%w2. ALL m k.
-                 m + k <= n1 + n2 & k < n2 & n2 <= m + k -->
-                 WSEG m k (WCAT (w1, w2)) =
-                 WCAT (WSEG (m + k - n2) 0 w1, WSEG (n2 - k) k w2)))"
-  by (import word_base WSEG_WCAT_WSEG)
-
-lemma BIT_EQ_IMP_WORD_EQ: "RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
-        (%w2. (ALL k<n. bit k w1 = bit k w2) --> w1 = w2))"
-  by (import word_base BIT_EQ_IMP_WORD_EQ)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL" word_num
-
-definition
-  LVAL :: "('a => nat) => nat => 'a list => nat"  where
-  "LVAL == %f b. foldl (%e x. b * e + f x) 0"
-
-lemma LVAL_DEF: "LVAL f b l = foldl (%e x. b * e + f x) 0 l"
-  by (import word_num LVAL_DEF)
-
-consts
-  NVAL :: "('a => nat) => nat => 'a word => nat" 
-
-specification (NVAL) NVAL_DEF: "ALL f b l. NVAL f b (WORD l) = LVAL f b l"
-  by (import word_num NVAL_DEF)
-
-lemma LVAL: "(ALL (x::'a => nat) xa::nat. LVAL x xa [] = (0::nat)) &
-(ALL (x::'a list) (xa::'a => nat) (xb::nat) xc::'a.
-    LVAL xa xb (xc # x) = xa xc * xb ^ length x + LVAL xa xb x)"
-  by (import word_num LVAL)
-
-lemma LVAL_SNOC: "LVAL f b (SNOC h l) = LVAL f b l * b + f h"
-  by (import word_num LVAL_SNOC)
-
-lemma LVAL_MAX: "(!!x. f x < b) ==> LVAL f b l < b ^ length l"
-  by (import word_num LVAL_MAX)
-
-lemma NVAL_MAX: "(!!x. f x < b) ==> RES_FORALL (PWORDLEN n) (%w. NVAL f b w < b ^ n)"
-  by (import word_num NVAL_MAX)
-
-lemma NVAL0: "NVAL x xa (WORD []) = 0"
-  by (import word_num NVAL0)
-
-lemma NVAL1: "NVAL x xa (WORD [xb]) = x xb"
-  by (import word_num NVAL1)
-
-lemma NVAL_WORDLEN_0: "RES_FORALL (PWORDLEN 0) (%w. ALL fv r. NVAL fv r w = 0)"
-  by (import word_num NVAL_WORDLEN_0)
-
-lemma NVAL_WCAT1: "NVAL f b (WCAT (w, WORD [x])) = NVAL f b w * b + f x"
-  by (import word_num NVAL_WCAT1)
-
-lemma NVAL_WCAT2: "RES_FORALL (PWORDLEN n)
- (%w. ALL f b x. NVAL f b (WCAT (WORD [x], w)) = f x * b ^ n + NVAL f b w)"
-  by (import word_num NVAL_WCAT2)
-
-lemma NVAL_WCAT: "RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN m)
-        (%w2. ALL f b.
-                 NVAL f b (WCAT (w1, w2)) =
-                 NVAL f b w1 * b ^ m + NVAL f b w2))"
-  by (import word_num NVAL_WCAT)
-
-consts
-  NLIST :: "nat => (nat => 'a) => nat => nat => 'a list" 
-
-specification (NLIST) NLIST_DEF: "(ALL (frep::nat => 'a) (b::nat) m::nat. NLIST (0::nat) frep b m = []) &
-(ALL (n::nat) (frep::nat => 'a) (b::nat) m::nat.
-    NLIST (Suc n) frep b m =
-    SNOC (frep (m mod b)) (NLIST n frep b (m div b)))"
-  by (import word_num NLIST_DEF)
-
-definition
-  NWORD :: "nat => (nat => 'a) => nat => nat => 'a word"  where
-  "NWORD == %n frep b m. WORD (NLIST n frep b m)"
-
-lemma NWORD_DEF: "NWORD n frep b m = WORD (NLIST n frep b m)"
-  by (import word_num NWORD_DEF)
-
-lemma NWORD_LENGTH: "WORDLEN (NWORD x xa xb xc) = x"
-  by (import word_num NWORD_LENGTH)
-
-lemma NWORD_PWORDLEN: "IN (NWORD x xa xb xc) (PWORDLEN x)"
-  by (import word_num NWORD_PWORDLEN)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL" word_bitop
-
-consts
-  PBITOP :: "('a word => 'b word) => bool" 
-
-defs
-  PBITOP_primdef: "PBITOP ==
-GSPEC
- (%oper.
-     (oper,
-      ALL n.
-         RES_FORALL (PWORDLEN n)
-          (%w. IN (oper w) (PWORDLEN n) &
-               (ALL m k.
-                   m + k <= n --> oper (WSEG m k w) = WSEG m k (oper w)))))"
-
-lemma PBITOP_def: "PBITOP =
-GSPEC
- (%oper.
-     (oper,
-      ALL n.
-         RES_FORALL (PWORDLEN n)
-          (%w. IN (oper w) (PWORDLEN n) &
-               (ALL m k.
-                   m + k <= n --> oper (WSEG m k w) = WSEG m k (oper w)))))"
-  by (import word_bitop PBITOP_def)
-
-lemma IN_PBITOP: "IN oper PBITOP =
-(ALL n.
-    RES_FORALL (PWORDLEN n)
-     (%w. IN (oper w) (PWORDLEN n) &
-          (ALL m k. m + k <= n --> oper (WSEG m k w) = WSEG m k (oper w))))"
-  by (import word_bitop IN_PBITOP)
-
-lemma PBITOP_PWORDLEN: "RES_FORALL PBITOP
- (%oper. ALL n. RES_FORALL (PWORDLEN n) (%w. IN (oper w) (PWORDLEN n)))"
-  by (import word_bitop PBITOP_PWORDLEN)
-
-lemma PBITOP_WSEG: "RES_FORALL PBITOP
- (%oper.
-     ALL n.
-        RES_FORALL (PWORDLEN n)
-         (%w. ALL m k.
-                 m + k <= n --> oper (WSEG m k w) = WSEG m k (oper w)))"
-  by (import word_bitop PBITOP_WSEG)
-
-lemma PBITOP_BIT: "RES_FORALL PBITOP
- (%oper.
-     ALL n.
-        RES_FORALL (PWORDLEN n)
-         (%w. ALL k<n. oper (WORD [bit k w]) = WORD [bit k (oper w)]))"
-  by (import word_bitop PBITOP_BIT)
-
-consts
-  PBITBOP :: "('a word => 'b word => 'c word) => bool" 
-
-defs
-  PBITBOP_primdef: "PBITBOP ==
-GSPEC
- (%oper.
-     (oper,
-      ALL n.
-         RES_FORALL (PWORDLEN n)
-          (%w1. RES_FORALL (PWORDLEN n)
-                 (%w2. IN (oper w1 w2) (PWORDLEN n) &
-                       (ALL m k.
-                           m + k <= n -->
-                           oper (WSEG m k w1) (WSEG m k w2) =
-                           WSEG m k (oper w1 w2))))))"
-
-lemma PBITBOP_def: "PBITBOP =
-GSPEC
- (%oper.
-     (oper,
-      ALL n.
-         RES_FORALL (PWORDLEN n)
-          (%w1. RES_FORALL (PWORDLEN n)
-                 (%w2. IN (oper w1 w2) (PWORDLEN n) &
-                       (ALL m k.
-                           m + k <= n -->
-                           oper (WSEG m k w1) (WSEG m k w2) =
-                           WSEG m k (oper w1 w2))))))"
-  by (import word_bitop PBITBOP_def)
-
-lemma IN_PBITBOP: "IN oper PBITBOP =
-(ALL n.
-    RES_FORALL (PWORDLEN n)
-     (%w1. RES_FORALL (PWORDLEN n)
-            (%w2. IN (oper w1 w2) (PWORDLEN n) &
-                  (ALL m k.
-                      m + k <= n -->
-                      oper (WSEG m k w1) (WSEG m k w2) =
-                      WSEG m k (oper w1 w2)))))"
-  by (import word_bitop IN_PBITBOP)
-
-lemma PBITBOP_PWORDLEN: "RES_FORALL PBITBOP
- (%oper.
-     ALL n.
-        RES_FORALL (PWORDLEN n)
-         (%w1. RES_FORALL (PWORDLEN n) (%w2. IN (oper w1 w2) (PWORDLEN n))))"
-  by (import word_bitop PBITBOP_PWORDLEN)
-
-lemma PBITBOP_WSEG: "RES_FORALL PBITBOP
- (%oper.
-     ALL n.
-        RES_FORALL (PWORDLEN n)
-         (%w1. RES_FORALL (PWORDLEN n)
-                (%w2. ALL m k.
-                         m + k <= n -->
-                         oper (WSEG m k w1) (WSEG m k w2) =
-                         WSEG m k (oper w1 w2))))"
-  by (import word_bitop PBITBOP_WSEG)
-
-lemma PBITBOP_EXISTS: "EX x. ALL l1 l2. x (WORD l1) (WORD l2) = WORD (map2 f l1 l2)"
-  by (import word_bitop PBITBOP_EXISTS)
-
-consts
-  WMAP :: "('a => 'b) => 'a word => 'b word" 
-
-specification (WMAP) WMAP_DEF: "ALL f l. WMAP f (WORD l) = WORD (map f l)"
-  by (import word_bitop WMAP_DEF)
-
-lemma WMAP_PWORDLEN: "RES_FORALL (PWORDLEN n) (%w. ALL f. IN (WMAP f w) (PWORDLEN n))"
-  by (import word_bitop WMAP_PWORDLEN)
-
-lemma WMAP_0: "WMAP (x::'a => 'b) (WORD []) = WORD []"
-  by (import word_bitop WMAP_0)
-
-lemma WMAP_BIT: "RES_FORALL (PWORDLEN n) (%w. ALL k<n. ALL f. bit k (WMAP f w) = f (bit k w))"
-  by (import word_bitop WMAP_BIT)
-
-lemma WMAP_WSEG: "RES_FORALL (PWORDLEN n)
- (%w. ALL m k.
-         m + k <= n --> (ALL f. WMAP f (WSEG m k w) = WSEG m k (WMAP f w)))"
-  by (import word_bitop WMAP_WSEG)
-
-lemma WMAP_PBITOP: "IN (WMAP f) PBITOP"
-  by (import word_bitop WMAP_PBITOP)
-
-lemma WMAP_WCAT: "WMAP (f::'a => 'b) (WCAT (w1::'a word, w2::'a word)) =
-WCAT (WMAP f w1, WMAP f w2)"
-  by (import word_bitop WMAP_WCAT)
-
-lemma WMAP_o: "WMAP (g::'b => 'c) (WMAP (f::'a => 'b) (w::'a word)) = WMAP (g o f) w"
-  by (import word_bitop WMAP_o)
-
-consts
-  FORALLBITS :: "('a => bool) => 'a word => bool" 
-
-specification (FORALLBITS) FORALLBITS_DEF: "ALL P l. FORALLBITS P (WORD l) = list_all P l"
-  by (import word_bitop FORALLBITS_DEF)
-
-lemma FORALLBITS: "RES_FORALL (PWORDLEN n) (%w. ALL P. FORALLBITS P w = (ALL k<n. P (bit k w)))"
-  by (import word_bitop FORALLBITS)
-
-lemma FORALLBITS_WSEG: "RES_FORALL (PWORDLEN n)
- (%w. ALL P.
-         FORALLBITS P w -->
-         (ALL m k. m + k <= n --> FORALLBITS P (WSEG m k w)))"
-  by (import word_bitop FORALLBITS_WSEG)
-
-lemma FORALLBITS_WCAT: "FORALLBITS P (WCAT (w1, w2)) = (FORALLBITS P w1 & FORALLBITS P w2)"
-  by (import word_bitop FORALLBITS_WCAT)
-
-consts
-  EXISTSABIT :: "('a => bool) => 'a word => bool" 
-
-specification (EXISTSABIT) EXISTSABIT_DEF: "ALL P l. EXISTSABIT P (WORD l) = list_ex P l"
-  by (import word_bitop EXISTSABIT_DEF)
-
-lemma NOT_EXISTSABIT: "(~ EXISTSABIT P w) = FORALLBITS (Not o P) w"
-  by (import word_bitop NOT_EXISTSABIT)
-
-lemma NOT_FORALLBITS: "(~ FORALLBITS P w) = EXISTSABIT (Not o P) w"
-  by (import word_bitop NOT_FORALLBITS)
-
-lemma EXISTSABIT: "RES_FORALL (PWORDLEN n) (%w. ALL P. EXISTSABIT P w = (EX k<n. P (bit k w)))"
-  by (import word_bitop EXISTSABIT)
-
-lemma EXISTSABIT_WSEG: "RES_FORALL (PWORDLEN n)
- (%w. ALL m k.
-         m + k <= n -->
-         (ALL P. EXISTSABIT P (WSEG m k w) --> EXISTSABIT P w))"
-  by (import word_bitop EXISTSABIT_WSEG)
-
-lemma EXISTSABIT_WCAT: "EXISTSABIT P (WCAT (w1, w2)) = (EXISTSABIT P w1 | EXISTSABIT P w2)"
-  by (import word_bitop EXISTSABIT_WCAT)
-
-definition
-  SHR :: "bool => 'a => 'a word => 'a word * 'a"  where
-  "SHR ==
-%f b w.
-   (WCAT
-     (if f then WSEG 1 (PRE (WORDLEN w)) w else WORD [b],
-      WSEG (PRE (WORDLEN w)) 1 w),
-    bit 0 w)"
-
-lemma SHR_DEF: "SHR f b w =
-(WCAT
-  (if f then WSEG 1 (PRE (WORDLEN w)) w else WORD [b],
-   WSEG (PRE (WORDLEN w)) 1 w),
- bit 0 w)"
-  by (import word_bitop SHR_DEF)
-
-definition
-  SHL :: "bool => 'a word => 'a => 'a * 'a word"  where
-  "SHL ==
-%f w b.
-   (bit (PRE (WORDLEN w)) w,
-    WCAT (WSEG (PRE (WORDLEN w)) 0 w, if f then WSEG 1 0 w else WORD [b]))"
-
-lemma SHL_DEF: "SHL f w b =
-(bit (PRE (WORDLEN w)) w,
- WCAT (WSEG (PRE (WORDLEN w)) 0 w, if f then WSEG 1 0 w else WORD [b]))"
-  by (import word_bitop SHL_DEF)
-
-lemma SHR_WSEG: "RES_FORALL (PWORDLEN n)
- (%w. ALL m k.
-         m + k <= n -->
-         0 < m -->
-         (ALL f b.
-             SHR f b (WSEG m k w) =
-             (if f
-              then WCAT (WSEG 1 (k + (m - 1)) w, WSEG (m - 1) (k + 1) w)
-              else WCAT (WORD [b], WSEG (m - 1) (k + 1) w),
-              bit k w)))"
-  by (import word_bitop SHR_WSEG)
-
-lemma SHR_WSEG_1F: "RES_FORALL (PWORDLEN n)
- (%w. ALL b m k.
-         m + k <= n -->
-         0 < m -->
-         SHR False b (WSEG m k w) =
-         (WCAT (WORD [b], WSEG (m - 1) (k + 1) w), bit k w))"
-  by (import word_bitop SHR_WSEG_1F)
-
-lemma SHR_WSEG_NF: "RES_FORALL (PWORDLEN n)
- (%w. ALL m k.
-         m + k < n -->
-         0 < m -->
-         SHR False (bit (m + k) w) (WSEG m k w) =
-         (WSEG m (k + 1) w, bit k w))"
-  by (import word_bitop SHR_WSEG_NF)
-
-lemma SHL_WSEG: "RES_FORALL (PWORDLEN n)
- (%w. ALL m k.
-         m + k <= n -->
-         0 < m -->
-         (ALL f b.
-             SHL f (WSEG m k w) b =
-             (bit (k + (m - 1)) w,
-              if f then WCAT (WSEG (m - 1) k w, WSEG 1 k w)
-              else WCAT (WSEG (m - 1) k w, WORD [b]))))"
-  by (import word_bitop SHL_WSEG)
-
-lemma SHL_WSEG_1F: "RES_FORALL (PWORDLEN n)
- (%w. ALL b m k.
-         m + k <= n -->
-         0 < m -->
-         SHL False (WSEG m k w) b =
-         (bit (k + (m - 1)) w, WCAT (WSEG (m - 1) k w, WORD [b])))"
-  by (import word_bitop SHL_WSEG_1F)
-
-lemma SHL_WSEG_NF: "RES_FORALL (PWORDLEN n)
- (%w. ALL m k.
-         m + k <= n -->
-         0 < m -->
-         0 < k -->
-         SHL False (WSEG m k w) (bit (k - 1) w) =
-         (bit (k + (m - 1)) w, WSEG m (k - 1) w))"
-  by (import word_bitop SHL_WSEG_NF)
-
-lemma WSEG_SHL: "RES_FORALL (PWORDLEN (Suc n))
- (%w. ALL m k.
-         0 < k & m + k <= Suc n -->
-         (ALL b. WSEG m k (snd (SHL f w b)) = WSEG m (k - 1) w))"
-  by (import word_bitop WSEG_SHL)
-
-lemma WSEG_SHL_0: "RES_FORALL (PWORDLEN (Suc n))
- (%w. ALL m b.
-         0 < m & m <= Suc n -->
-         WSEG m 0 (snd (SHL f w b)) =
-         WCAT (WSEG (m - 1) 0 w, if f then WSEG 1 0 w else WORD [b]))"
-  by (import word_bitop WSEG_SHL_0)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL" 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/HOL" bword_arith
-
-consts
-  ACARRY :: "nat => bool word => bool word => bool => bool" 
-
-specification (ACARRY) ACARRY_DEF: "(ALL w1 w2 cin. ACARRY 0 w1 w2 cin = cin) &
-(ALL n w1 w2 cin.
-    ACARRY (Suc n) w1 w2 cin =
-    VB ((BV (bit n w1) + BV (bit n w2) + BV (ACARRY n w1 w2 cin)) div 2))"
-  by (import bword_arith ACARRY_DEF)
-
-consts
-  ICARRY :: "nat => bool word => bool word => bool => bool" 
-
-specification (ICARRY) ICARRY_DEF: "(ALL w1 w2 cin. ICARRY 0 w1 w2 cin = cin) &
-(ALL n w1 w2 cin.
-    ICARRY (Suc n) w1 w2 cin =
-    (bit n w1 & bit n w2 | (bit n w1 | bit n w2) & ICARRY n w1 w2 cin))"
-  by (import bword_arith ICARRY_DEF)
-
-lemma ACARRY_EQ_ICARRY: "RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
-        (%w2. ALL cin k.
-                 k <= n --> ACARRY k w1 w2 cin = ICARRY k w1 w2 cin))"
-  by (import bword_arith ACARRY_EQ_ICARRY)
-
-lemma BNVAL_LESS_EQ: "RES_FORALL (PWORDLEN n) (%w. BNVAL w <= 2 ^ n - 1)"
-  by (import bword_arith BNVAL_LESS_EQ)
-
-lemma ADD_BNVAL_LESS_EQ1: "RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
-        (%w2. (BNVAL w1 + (BNVAL w2 + BV cin)) div 2 ^ n <= Suc 0))"
-  by (import bword_arith ADD_BNVAL_LESS_EQ1)
-
-lemma ADD_BV_BNVAL_DIV_LESS_EQ1: "RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
-        (%w2. (BV x1 + BV x2 +
-               (BNVAL w1 + (BNVAL w2 + BV cin)) div 2 ^ n) div
-              2
-              <= 1))"
-  by (import bword_arith ADD_BV_BNVAL_DIV_LESS_EQ1)
-
-lemma ADD_BV_BNVAL_LESS_EQ: "RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
-        (%w2. BV x1 + BV x2 + (BNVAL w1 + (BNVAL w2 + BV cin))
-              <= Suc (2 ^ Suc n)))"
-  by (import bword_arith ADD_BV_BNVAL_LESS_EQ)
-
-lemma ADD_BV_BNVAL_LESS_EQ1: "RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
-        (%w2. (BV x1 + BV x2 + (BNVAL w1 + (BNVAL w2 + BV cin))) div
-              2 ^ Suc n
-              <= 1))"
-  by (import bword_arith ADD_BV_BNVAL_LESS_EQ1)
-
-lemma ACARRY_EQ_ADD_DIV: "RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
-        (%w2. ALL k<n.
-                 BV (ACARRY k w1 w2 cin) =
-                 (BNVAL (WSEG k 0 w1) + BNVAL (WSEG k 0 w2) + BV cin) div
-                 2 ^ k))"
-  by (import bword_arith ACARRY_EQ_ADD_DIV)
-
-lemma ADD_WORD_SPLIT: "RES_FORALL (PWORDLEN (n1 + n2))
- (%w1. RES_FORALL (PWORDLEN (n1 + n2))
-        (%w2. ALL cin.
-                 NBWORD (n1 + n2) (BNVAL w1 + BNVAL w2 + BV cin) =
-                 WCAT
-                  (NBWORD n1
-                    (BNVAL (WSEG n1 n2 w1) + BNVAL (WSEG n1 n2 w2) +
-                     BV (ACARRY n2 w1 w2 cin)),
-                   NBWORD n2
-                    (BNVAL (WSEG n2 0 w1) + BNVAL (WSEG n2 0 w2) +
-                     BV cin))))"
-  by (import bword_arith ADD_WORD_SPLIT)
-
-lemma WSEG_NBWORD_ADD: "RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
-        (%w2. ALL m k cin.
-                 m + k <= n -->
-                 WSEG m k (NBWORD n (BNVAL w1 + BNVAL w2 + BV cin)) =
-                 NBWORD m
-                  (BNVAL (WSEG m k w1) + BNVAL (WSEG m k w2) +
-                   BV (ACARRY k w1 w2 cin))))"
-  by (import bword_arith WSEG_NBWORD_ADD)
-
-lemma ADD_NBWORD_EQ0_SPLIT: "RES_FORALL (PWORDLEN (n1 + n2))
- (%w1. RES_FORALL (PWORDLEN (n1 + n2))
-        (%w2. ALL cin.
-                 (NBWORD (n1 + n2) (BNVAL w1 + BNVAL w2 + BV cin) =
-                  NBWORD (n1 + n2) 0) =
-                 (NBWORD n1
-                   (BNVAL (WSEG n1 n2 w1) + BNVAL (WSEG n1 n2 w2) +
-                    BV (ACARRY n2 w1 w2 cin)) =
-                  NBWORD n1 0 &
-                  NBWORD n2
-                   (BNVAL (WSEG n2 0 w1) + BNVAL (WSEG n2 0 w2) + BV cin) =
-                  NBWORD n2 0)))"
-  by (import bword_arith ADD_NBWORD_EQ0_SPLIT)
-
-lemma ACARRY_MSB: "RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
-        (%w2. ALL cin.
-                 ACARRY n w1 w2 cin =
-                 bit n (NBWORD (Suc n) (BNVAL w1 + BNVAL w2 + BV cin))))"
-  by (import bword_arith ACARRY_MSB)
-
-lemma ACARRY_WSEG: "RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
-        (%w2. ALL cin k m.
-                 k < m & m <= n -->
-                 ACARRY k (WSEG m 0 w1) (WSEG m 0 w2) cin =
-                 ACARRY k w1 w2 cin))"
-  by (import bword_arith ACARRY_WSEG)
-
-lemma ICARRY_WSEG: "RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
-        (%w2. ALL cin k m.
-                 k < m & m <= n -->
-                 ICARRY k (WSEG m 0 w1) (WSEG m 0 w2) cin =
-                 ICARRY k w1 w2 cin))"
-  by (import bword_arith ICARRY_WSEG)
-
-lemma ACARRY_ACARRY_WSEG: "RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
-        (%w2. ALL cin m k1 k2.
-                 k1 < m & k2 < n & m + k2 <= n -->
-                 ACARRY k1 (WSEG m k2 w1) (WSEG m k2 w2)
-                  (ACARRY k2 w1 w2 cin) =
-                 ACARRY (k1 + k2) w1 w2 cin))"
-  by (import bword_arith ACARRY_ACARRY_WSEG)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL" 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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/HOL4Word32.thy
--- a/src/HOL/Import/HOL/HOL4Word32.thy	Sat Mar 03 21:51:38 2012 +0100
+++ /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/HOL" 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/HOL" word32
-
-consts
-  HB :: "nat" 
-
-defs
-  HB_primdef: "HB ==
-NUMERAL
- (NUMERAL_BIT1
-   (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO)))))"
-
-lemma HB_def: "HB =
-NUMERAL
- (NUMERAL_BIT1
-   (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO)))))"
-  by (import word32 HB_def)
-
-consts
-  WL :: "nat" 
-
-defs
-  WL_primdef: "WL == Suc HB"
-
-lemma WL_def: "WL = Suc HB"
-  by (import word32 WL_def)
-
-consts
-  MODw :: "nat => nat" 
-
-defs
-  MODw_primdef: "MODw == %n. n mod 2 ^ WL"
-
-lemma MODw_def: "MODw n = n mod 2 ^ WL"
-  by (import word32 MODw_def)
-
-consts
-  INw :: "nat => bool" 
-
-defs
-  INw_primdef: "INw == %n. n < 2 ^ WL"
-
-lemma INw_def: "INw n = (n < 2 ^ WL)"
-  by (import word32 INw_def)
-
-consts
-  EQUIV :: "nat => nat => bool" 
-
-defs
-  EQUIV_primdef: "EQUIV == %x y. MODw x = MODw y"
-
-lemma EQUIV_def: "EQUIV x y = (MODw x = MODw y)"
-  by (import word32 EQUIV_def)
-
-lemma EQUIV_QT: "EQUIV x y = (EQUIV x = EQUIV y)"
-  by (import word32 EQUIV_QT)
-
-lemma FUNPOW_THM2: "(f ^^ Suc n) x = f ((f ^^ n) x)"
-  by (import word32 FUNPOW_THM2)
-
-lemma FUNPOW_COMP: "(f ^^ m) ((f ^^ n) a) = (f ^^ (m + n)) a"
-  by (import word32 FUNPOW_COMP)
-
-lemma INw_MODw: "INw (MODw n)"
-  by (import word32 INw_MODw)
-
-lemma TOw_IDEM: "INw a ==> MODw a = a"
-  by (import word32 TOw_IDEM)
-
-lemma MODw_IDEM2: "MODw (MODw a) = MODw a"
-  by (import word32 MODw_IDEM2)
-
-lemma TOw_QT: "EQUIV (MODw a) a"
-  by (import word32 TOw_QT)
-
-lemma MODw_THM: "MODw = BITS HB 0"
-  by (import word32 MODw_THM)
-
-lemma MOD_ADD: "MODw (a + b) = MODw (MODw a + MODw b)"
-  by (import word32 MOD_ADD)
-
-lemma MODw_MULT: "MODw (a * b) = MODw (MODw a * MODw b)"
-  by (import word32 MODw_MULT)
-
-consts
-  AONE :: "nat" 
-
-defs
-  AONE_primdef: "AONE == 1"
-
-lemma AONE_def: "AONE = 1"
-  by (import word32 AONE_def)
-
-lemma ADD_QT: "(ALL n. EQUIV (0 + n) n) & (ALL m n. EQUIV (Suc m + n) (Suc (m + n)))"
-  by (import word32 ADD_QT)
-
-lemma ADD_0_QT: "EQUIV (a + 0) a"
-  by (import word32 ADD_0_QT)
-
-lemma ADD_COMM_QT: "EQUIV (a + b) (b + a)"
-  by (import word32 ADD_COMM_QT)
-
-lemma ADD_ASSOC_QT: "EQUIV (a + (b + c)) (a + b + c)"
-  by (import word32 ADD_ASSOC_QT)
-
-lemma MULT_QT: "(ALL n. EQUIV (0 * n) 0) & (ALL m n. EQUIV (Suc m * n) (m * n + n))"
-  by (import word32 MULT_QT)
-
-lemma ADD1_QT: "EQUIV (Suc m) (m + AONE)"
-  by (import word32 ADD1_QT)
-
-lemma ADD_CLAUSES_QT: "(ALL m. EQUIV (0 + m) m) &
-(ALL m. EQUIV (m + 0) m) &
-(ALL m n. EQUIV (Suc m + n) (Suc (m + n))) &
-(ALL m n. EQUIV (m + Suc n) (Suc (m + n)))"
-  by (import word32 ADD_CLAUSES_QT)
-
-lemma SUC_EQUIV_COMP: "EQUIV (Suc a) b ==> EQUIV a (b + (2 ^ WL - 1))"
-  by (import word32 SUC_EQUIV_COMP)
-
-lemma INV_SUC_EQ_QT: "EQUIV (Suc m) (Suc n) = EQUIV m n"
-  by (import word32 INV_SUC_EQ_QT)
-
-lemma ADD_INV_0_QT: "EQUIV (m + n) m ==> EQUIV n 0"
-  by (import word32 ADD_INV_0_QT)
-
-lemma ADD_INV_0_EQ_QT: "EQUIV (m + n) m = EQUIV n 0"
-  by (import word32 ADD_INV_0_EQ_QT)
-
-lemma EQ_ADD_LCANCEL_QT: "EQUIV (m + n) (m + p) = EQUIV n p"
-  by (import word32 EQ_ADD_LCANCEL_QT)
-
-lemma EQ_ADD_RCANCEL_QT: "EQUIV (x + xb) (xa + xb) = EQUIV x xa"
-  by (import word32 EQ_ADD_RCANCEL_QT)
-
-lemma LEFT_ADD_DISTRIB_QT: "EQUIV (p * (m + n)) (p * m + p * n)"
-  by (import word32 LEFT_ADD_DISTRIB_QT)
-
-lemma MULT_ASSOC_QT: "EQUIV (m * (n * p)) (m * n * p)"
-  by (import word32 MULT_ASSOC_QT)
-
-lemma MULT_COMM_QT: "EQUIV (m * n) (n * m)"
-  by (import word32 MULT_COMM_QT)
-
-lemma MULT_CLAUSES_QT: "EQUIV (0 * m) 0 &
-EQUIV (m * 0) 0 &
-EQUIV (AONE * m) m &
-EQUIV (m * AONE) m &
-EQUIV (Suc m * n) (m * n + n) & EQUIV (m * Suc n) (m + m * n)"
-  by (import word32 MULT_CLAUSES_QT)
-
-consts
-  MSBn :: "nat => bool" 
-
-defs
-  MSBn_primdef: "MSBn == bit HB"
-
-lemma MSBn_def: "MSBn = bit HB"
-  by (import word32 MSBn_def)
-
-consts
-  ONE_COMP :: "nat => nat" 
-
-defs
-  ONE_COMP_primdef: "ONE_COMP == %x. 2 ^ WL - 1 - MODw x"
-
-lemma ONE_COMP_def: "ONE_COMP x = 2 ^ WL - 1 - MODw x"
-  by (import word32 ONE_COMP_def)
-
-consts
-  TWO_COMP :: "nat => nat" 
-
-defs
-  TWO_COMP_primdef: "TWO_COMP == %x. 2 ^ WL - MODw x"
-
-lemma TWO_COMP_def: "TWO_COMP x = 2 ^ WL - MODw x"
-  by (import word32 TWO_COMP_def)
-
-lemma ADD_TWO_COMP_QT: "EQUIV (MODw a + TWO_COMP a) 0"
-  by (import word32 ADD_TWO_COMP_QT)
-
-lemma TWO_COMP_ONE_COMP_QT: "EQUIV (TWO_COMP a) (ONE_COMP a + AONE)"
-  by (import word32 TWO_COMP_ONE_COMP_QT)
-
-lemma BIT_EQUIV_THM: "(ALL xb<WL. bit xb x = bit xb xa) = EQUIV x xa"
-  by (import word32 BIT_EQUIV_THM)
-
-lemma BITS_SUC2: "BITS (Suc n) 0 a = SLICE (Suc n) (Suc n) a + BITS n 0 a"
-  by (import word32 BITS_SUC2)
-
-lemma BITWISE_ONE_COMP_THM: "BITWISE WL (%x y. ~ x) a b = ONE_COMP a"
-  by (import word32 BITWISE_ONE_COMP_THM)
-
-lemma ONE_COMP_THM: "xa < WL ==> bit xa (ONE_COMP x) = (~ bit xa x)"
-  by (import word32 ONE_COMP_THM)
-
-consts
-  OR :: "nat => nat => nat" 
-
-defs
-  OR_primdef: "OR == BITWISE WL op |"
-
-lemma OR_def: "OR = BITWISE WL op |"
-  by (import word32 OR_def)
-
-consts
-  AND :: "nat => nat => nat" 
-
-defs
-  AND_primdef: "AND == BITWISE WL op &"
-
-lemma AND_def: "AND = BITWISE WL op &"
-  by (import word32 AND_def)
-
-consts
-  EOR :: "nat => nat => nat" 
-
-defs
-  EOR_primdef: "EOR == BITWISE WL op ~="
-
-lemma EOR_def: "EOR = BITWISE WL op ~="
-  by (import word32 EOR_def)
-
-consts
-  COMP0 :: "nat" 
-
-defs
-  COMP0_primdef: "COMP0 == ONE_COMP 0"
-
-lemma COMP0_def: "COMP0 = ONE_COMP 0"
-  by (import word32 COMP0_def)
-
-lemma BITWISE_THM2: "(ALL x<WL. oper (bit x a) (bit x b) = bit x y) =
-EQUIV (BITWISE WL oper a b) y"
-  by (import word32 BITWISE_THM2)
-
-lemma OR_ASSOC_QT: "EQUIV (OR a (OR b c)) (OR (OR a b) c)"
-  by (import word32 OR_ASSOC_QT)
-
-lemma OR_COMM_QT: "EQUIV (OR a b) (OR b a)"
-  by (import word32 OR_COMM_QT)
-
-lemma OR_ABSORB_QT: "EQUIV (AND a (OR a b)) a"
-  by (import word32 OR_ABSORB_QT)
-
-lemma OR_IDEM_QT: "EQUIV (OR a a) a"
-  by (import word32 OR_IDEM_QT)
-
-lemma AND_ASSOC_QT: "EQUIV (AND a (AND b c)) (AND (AND a b) c)"
-  by (import word32 AND_ASSOC_QT)
-
-lemma AND_COMM_QT: "EQUIV (AND a b) (AND b a)"
-  by (import word32 AND_COMM_QT)
-
-lemma AND_ABSORB_QT: "EQUIV (OR a (AND a b)) a"
-  by (import word32 AND_ABSORB_QT)
-
-lemma AND_IDEM_QT: "EQUIV (AND a a) a"
-  by (import word32 AND_IDEM_QT)
-
-lemma OR_COMP_QT: "EQUIV (OR a (ONE_COMP a)) COMP0"
-  by (import word32 OR_COMP_QT)
-
-lemma AND_COMP_QT: "EQUIV (AND a (ONE_COMP a)) 0"
-  by (import word32 AND_COMP_QT)
-
-lemma ONE_COMP_QT: "EQUIV (ONE_COMP (ONE_COMP a)) a"
-  by (import word32 ONE_COMP_QT)
-
-lemma RIGHT_AND_OVER_OR_QT: "EQUIV (AND (OR a b) c) (OR (AND a c) (AND b c))"
-  by (import word32 RIGHT_AND_OVER_OR_QT)
-
-lemma RIGHT_OR_OVER_AND_QT: "EQUIV (OR (AND a b) c) (AND (OR a c) (OR b c))"
-  by (import word32 RIGHT_OR_OVER_AND_QT)
-
-lemma DE_MORGAN_THM_QT: "EQUIV (ONE_COMP (AND a b)) (OR (ONE_COMP a) (ONE_COMP b)) &
-EQUIV (ONE_COMP (OR a b)) (AND (ONE_COMP a) (ONE_COMP b))"
-  by (import word32 DE_MORGAN_THM_QT)
-
-lemma BIT_EQUIV: "[| n < WL; EQUIV a b |] ==> bit n a = bit n b"
-  by (import word32 BIT_EQUIV)
-
-lemma LSB_WELLDEF: "EQUIV a b ==> LSBn a = LSBn b"
-  by (import word32 LSB_WELLDEF)
-
-lemma MSB_WELLDEF: "EQUIV a b ==> MSBn a = MSBn b"
-  by (import word32 MSB_WELLDEF)
-
-lemma BITWISE_ISTEP: "0 < n
-==> BITWISE n oper (a div 2) (b div 2) =
-    BITWISE n oper a b div 2 + SBIT (oper (bit n a) (bit n b)) (n - 1)"
-  by (import word32 BITWISE_ISTEP)
-
-lemma BITWISE_EVAL: "BITWISE (Suc n) oper a b =
-2 * BITWISE n oper (a div 2) (b div 2) + SBIT (oper (LSBn a) (LSBn b)) 0"
-  by (import word32 BITWISE_EVAL)
-
-lemma BITWISE_WELLDEF: "EQUIV a b & EQUIV c d ==> EQUIV (BITWISE n oper a c) (BITWISE n oper b d)"
-  by (import word32 BITWISE_WELLDEF)
-
-lemma BITWISEw_WELLDEF: "EQUIV a b & EQUIV c d ==> EQUIV (BITWISE WL oper a c) (BITWISE WL oper b d)"
-  by (import word32 BITWISEw_WELLDEF)
-
-lemma SUC_WELLDEF: "EQUIV a b ==> EQUIV (Suc a) (Suc b)"
-  by (import word32 SUC_WELLDEF)
-
-lemma ADD_WELLDEF: "EQUIV a b & EQUIV c d ==> EQUIV (a + c) (b + d)"
-  by (import word32 ADD_WELLDEF)
-
-lemma MUL_WELLDEF: "EQUIV a b & EQUIV c d ==> EQUIV (a * c) (b * d)"
-  by (import word32 MUL_WELLDEF)
-
-lemma ONE_COMP_WELLDEF: "EQUIV a b ==> EQUIV (ONE_COMP a) (ONE_COMP b)"
-  by (import word32 ONE_COMP_WELLDEF)
-
-lemma TWO_COMP_WELLDEF: "EQUIV a b ==> EQUIV (TWO_COMP a) (TWO_COMP b)"
-  by (import word32 TWO_COMP_WELLDEF)
-
-lemma TOw_WELLDEF: "EQUIV a b ==> EQUIV (MODw a) (MODw b)"
-  by (import word32 TOw_WELLDEF)
-
-consts
-  LSR_ONE :: "nat => nat" 
-
-defs
-  LSR_ONE_primdef: "LSR_ONE == %a. MODw a div 2"
-
-lemma LSR_ONE_def: "LSR_ONE a = MODw a div 2"
-  by (import word32 LSR_ONE_def)
-
-consts
-  ASR_ONE :: "nat => nat" 
-
-defs
-  ASR_ONE_primdef: "ASR_ONE == %a. LSR_ONE a + SBIT (MSBn a) HB"
-
-lemma ASR_ONE_def: "ASR_ONE a = LSR_ONE a + SBIT (MSBn a) HB"
-  by (import word32 ASR_ONE_def)
-
-consts
-  ROR_ONE :: "nat => nat" 
-
-defs
-  ROR_ONE_primdef: "ROR_ONE == %a. LSR_ONE a + SBIT (LSBn a) HB"
-
-lemma ROR_ONE_def: "ROR_ONE a = LSR_ONE a + SBIT (LSBn a) HB"
-  by (import word32 ROR_ONE_def)
-
-consts
-  RRXn :: "bool => nat => nat" 
-
-defs
-  RRXn_primdef: "RRXn == %c a. LSR_ONE a + SBIT c HB"
-
-lemma RRXn_def: "RRXn c a = LSR_ONE a + SBIT c HB"
-  by (import word32 RRXn_def)
-
-lemma LSR_ONE_WELLDEF: "EQUIV a b ==> EQUIV (LSR_ONE a) (LSR_ONE b)"
-  by (import word32 LSR_ONE_WELLDEF)
-
-lemma ASR_ONE_WELLDEF: "EQUIV a b ==> EQUIV (ASR_ONE a) (ASR_ONE b)"
-  by (import word32 ASR_ONE_WELLDEF)
-
-lemma ROR_ONE_WELLDEF: "EQUIV a b ==> EQUIV (ROR_ONE a) (ROR_ONE b)"
-  by (import word32 ROR_ONE_WELLDEF)
-
-lemma RRX_WELLDEF: "EQUIV a b ==> EQUIV (RRXn c a) (RRXn c b)"
-  by (import word32 RRX_WELLDEF)
-
-lemma LSR_ONE: "LSR_ONE = BITS HB 1"
-  by (import word32 LSR_ONE)
-
-typedef (open) word32 = "{x::nat => bool. EX xa. x = EQUIV xa}" 
-  by (rule typedef_helper,import word32 word32_TY_DEF)
-
-lemmas word32_TY_DEF = typedef_hol2hol4 [OF type_definition_word32]
-
-consts
-  mk_word32 :: "(nat => bool) => word32" 
-  dest_word32 :: "word32 => nat => bool" 
-
-specification (dest_word32 mk_word32) word32_tybij: "(ALL a. mk_word32 (dest_word32 a) = a) &
-(ALL r. (EX x. r = EQUIV x) = (dest_word32 (mk_word32 r) = r))"
-  by (import word32 word32_tybij)
-
-consts
-  w_0 :: "word32" 
-
-defs
-  w_0_primdef: "w_0 == mk_word32 (EQUIV 0)"
-
-lemma w_0_def: "w_0 = mk_word32 (EQUIV 0)"
-  by (import word32 w_0_def)
-
-consts
-  w_1 :: "word32" 
-
-defs
-  w_1_primdef: "w_1 == mk_word32 (EQUIV AONE)"
-
-lemma w_1_def: "w_1 = mk_word32 (EQUIV AONE)"
-  by (import word32 w_1_def)
-
-consts
-  w_T :: "word32" 
-
-defs
-  w_T_primdef: "w_T == mk_word32 (EQUIV COMP0)"
-
-lemma w_T_def: "w_T = mk_word32 (EQUIV COMP0)"
-  by (import word32 w_T_def)
-
-definition
-  word_suc :: "word32 => word32"  where
-  "word_suc == %T1. mk_word32 (EQUIV (Suc (Eps (dest_word32 T1))))"
-
-lemma word_suc: "word_suc T1 = mk_word32 (EQUIV (Suc (Eps (dest_word32 T1))))"
-  by (import word32 word_suc)
-
-definition
-  word_add :: "word32 => word32 => word32"  where
-  "word_add ==
-%T1 T2. mk_word32 (EQUIV (Eps (dest_word32 T1) + Eps (dest_word32 T2)))"
-
-lemma word_add: "word_add T1 T2 =
-mk_word32 (EQUIV (Eps (dest_word32 T1) + Eps (dest_word32 T2)))"
-  by (import word32 word_add)
-
-definition
-  word_mul :: "word32 => word32 => word32"  where
-  "word_mul ==
-%T1 T2. mk_word32 (EQUIV (Eps (dest_word32 T1) * Eps (dest_word32 T2)))"
-
-lemma word_mul: "word_mul T1 T2 =
-mk_word32 (EQUIV (Eps (dest_word32 T1) * Eps (dest_word32 T2)))"
-  by (import word32 word_mul)
-
-definition
-  word_1comp :: "word32 => word32"  where
-  "word_1comp == %T1. mk_word32 (EQUIV (ONE_COMP (Eps (dest_word32 T1))))"
-
-lemma word_1comp: "word_1comp T1 = mk_word32 (EQUIV (ONE_COMP (Eps (dest_word32 T1))))"
-  by (import word32 word_1comp)
-
-definition
-  word_2comp :: "word32 => word32"  where
-  "word_2comp == %T1. mk_word32 (EQUIV (TWO_COMP (Eps (dest_word32 T1))))"
-
-lemma word_2comp: "word_2comp T1 = mk_word32 (EQUIV (TWO_COMP (Eps (dest_word32 T1))))"
-  by (import word32 word_2comp)
-
-definition
-  word_lsr1 :: "word32 => word32"  where
-  "word_lsr1 == %T1. mk_word32 (EQUIV (LSR_ONE (Eps (dest_word32 T1))))"
-
-lemma word_lsr1: "word_lsr1 T1 = mk_word32 (EQUIV (LSR_ONE (Eps (dest_word32 T1))))"
-  by (import word32 word_lsr1)
-
-definition
-  word_asr1 :: "word32 => word32"  where
-  "word_asr1 == %T1. mk_word32 (EQUIV (ASR_ONE (Eps (dest_word32 T1))))"
-
-lemma word_asr1: "word_asr1 T1 = mk_word32 (EQUIV (ASR_ONE (Eps (dest_word32 T1))))"
-  by (import word32 word_asr1)
-
-definition
-  word_ror1 :: "word32 => word32"  where
-  "word_ror1 == %T1. mk_word32 (EQUIV (ROR_ONE (Eps (dest_word32 T1))))"
-
-lemma word_ror1: "word_ror1 T1 = mk_word32 (EQUIV (ROR_ONE (Eps (dest_word32 T1))))"
-  by (import word32 word_ror1)
-
-consts
-  RRX :: "bool => word32 => word32" 
-
-defs
-  RRX_primdef: "RRX == %T1 T2. mk_word32 (EQUIV (RRXn T1 (Eps (dest_word32 T2))))"
-
-lemma RRX_def: "RRX T1 T2 = mk_word32 (EQUIV (RRXn T1 (Eps (dest_word32 T2))))"
-  by (import word32 RRX_def)
-
-consts
-  LSB :: "word32 => bool" 
-
-defs
-  LSB_primdef: "LSB == %T1. LSBn (Eps (dest_word32 T1))"
-
-lemma LSB_def: "LSB T1 = LSBn (Eps (dest_word32 T1))"
-  by (import word32 LSB_def)
-
-consts
-  MSB :: "word32 => bool" 
-
-defs
-  MSB_primdef: "MSB == %T1. MSBn (Eps (dest_word32 T1))"
-
-lemma MSB_def: "MSB T1 = MSBn (Eps (dest_word32 T1))"
-  by (import word32 MSB_def)
-
-definition
-  bitwise_or :: "word32 => word32 => word32"  where
-  "bitwise_or ==
-%T1 T2. mk_word32 (EQUIV (OR (Eps (dest_word32 T1)) (Eps (dest_word32 T2))))"
-
-lemma bitwise_or: "bitwise_or T1 T2 =
-mk_word32 (EQUIV (OR (Eps (dest_word32 T1)) (Eps (dest_word32 T2))))"
-  by (import word32 bitwise_or)
-
-definition
-  bitwise_eor :: "word32 => word32 => word32"  where
-  "bitwise_eor ==
-%T1 T2.
-   mk_word32 (EQUIV (EOR (Eps (dest_word32 T1)) (Eps (dest_word32 T2))))"
-
-lemma bitwise_eor: "bitwise_eor T1 T2 =
-mk_word32 (EQUIV (EOR (Eps (dest_word32 T1)) (Eps (dest_word32 T2))))"
-  by (import word32 bitwise_eor)
-
-definition
-  bitwise_and :: "word32 => word32 => word32"  where
-  "bitwise_and ==
-%T1 T2.
-   mk_word32 (EQUIV (AND (Eps (dest_word32 T1)) (Eps (dest_word32 T2))))"
-
-lemma bitwise_and: "bitwise_and T1 T2 =
-mk_word32 (EQUIV (AND (Eps (dest_word32 T1)) (Eps (dest_word32 T2))))"
-  by (import word32 bitwise_and)
-
-consts
-  TOw :: "word32 => word32" 
-
-defs
-  TOw_primdef: "TOw == %T1. mk_word32 (EQUIV (MODw (Eps (dest_word32 T1))))"
-
-lemma TOw_def: "TOw T1 = mk_word32 (EQUIV (MODw (Eps (dest_word32 T1))))"
-  by (import word32 TOw_def)
-
-consts
-  n2w :: "nat => word32" 
-
-defs
-  n2w_primdef: "n2w == %n. mk_word32 (EQUIV n)"
-
-lemma n2w_def: "n2w n = mk_word32 (EQUIV n)"
-  by (import word32 n2w_def)
-
-consts
-  w2n :: "word32 => nat" 
-
-defs
-  w2n_primdef: "w2n == %w. MODw (Eps (dest_word32 w))"
-
-lemma w2n_def: "w2n w = MODw (Eps (dest_word32 w))"
-  by (import word32 w2n_def)
-
-lemma ADDw: "(ALL x. word_add w_0 x = x) &
-(ALL x xa. word_add (word_suc x) xa = word_suc (word_add x xa))"
-  by (import word32 ADDw)
-
-lemma ADD_0w: "word_add x w_0 = x"
-  by (import word32 ADD_0w)
-
-lemma ADD1w: "word_suc x = word_add x w_1"
-  by (import word32 ADD1w)
-
-lemma ADD_ASSOCw: "word_add x (word_add xa xb) = word_add (word_add x xa) xb"
-  by (import word32 ADD_ASSOCw)
-
-lemma ADD_CLAUSESw: "(ALL x. word_add w_0 x = x) &
-(ALL x. word_add x w_0 = x) &
-(ALL x xa. word_add (word_suc x) xa = word_suc (word_add x xa)) &
-(ALL x xa. word_add x (word_suc xa) = word_suc (word_add x xa))"
-  by (import word32 ADD_CLAUSESw)
-
-lemma ADD_COMMw: "word_add x xa = word_add xa x"
-  by (import word32 ADD_COMMw)
-
-lemma ADD_INV_0_EQw: "(word_add x xa = x) = (xa = w_0)"
-  by (import word32 ADD_INV_0_EQw)
-
-lemma EQ_ADD_LCANCELw: "(word_add x xa = word_add x xb) = (xa = xb)"
-  by (import word32 EQ_ADD_LCANCELw)
-
-lemma EQ_ADD_RCANCELw: "(word_add x xb = word_add xa xb) = (x = xa)"
-  by (import word32 EQ_ADD_RCANCELw)
-
-lemma LEFT_ADD_DISTRIBw: "word_mul xb (word_add x xa) = word_add (word_mul xb x) (word_mul xb xa)"
-  by (import word32 LEFT_ADD_DISTRIBw)
-
-lemma MULT_ASSOCw: "word_mul x (word_mul xa xb) = word_mul (word_mul x xa) xb"
-  by (import word32 MULT_ASSOCw)
-
-lemma MULT_COMMw: "word_mul x xa = word_mul xa x"
-  by (import word32 MULT_COMMw)
-
-lemma MULT_CLAUSESw: "word_mul w_0 x = w_0 &
-word_mul x w_0 = w_0 &
-word_mul w_1 x = x &
-word_mul x w_1 = x &
-word_mul (word_suc x) xa = word_add (word_mul x xa) xa &
-word_mul x (word_suc xa) = word_add x (word_mul x xa)"
-  by (import word32 MULT_CLAUSESw)
-
-lemma TWO_COMP_ONE_COMP: "word_2comp x = word_add (word_1comp x) w_1"
-  by (import word32 TWO_COMP_ONE_COMP)
-
-lemma OR_ASSOCw: "bitwise_or x (bitwise_or xa xb) = bitwise_or (bitwise_or x xa) xb"
-  by (import word32 OR_ASSOCw)
-
-lemma OR_COMMw: "bitwise_or x xa = bitwise_or xa x"
-  by (import word32 OR_COMMw)
-
-lemma OR_IDEMw: "bitwise_or x x = x"
-  by (import word32 OR_IDEMw)
-
-lemma OR_ABSORBw: "bitwise_and x (bitwise_or x xa) = x"
-  by (import word32 OR_ABSORBw)
-
-lemma AND_ASSOCw: "bitwise_and x (bitwise_and xa xb) = bitwise_and (bitwise_and x xa) xb"
-  by (import word32 AND_ASSOCw)
-
-lemma AND_COMMw: "bitwise_and x xa = bitwise_and xa x"
-  by (import word32 AND_COMMw)
-
-lemma AND_IDEMw: "bitwise_and x x = x"
-  by (import word32 AND_IDEMw)
-
-lemma AND_ABSORBw: "bitwise_or x (bitwise_and x xa) = x"
-  by (import word32 AND_ABSORBw)
-
-lemma ONE_COMPw: "word_1comp (word_1comp x) = x"
-  by (import word32 ONE_COMPw)
-
-lemma RIGHT_AND_OVER_ORw: "bitwise_and (bitwise_or x xa) xb =
-bitwise_or (bitwise_and x xb) (bitwise_and xa xb)"
-  by (import word32 RIGHT_AND_OVER_ORw)
-
-lemma RIGHT_OR_OVER_ANDw: "bitwise_or (bitwise_and x xa) xb =
-bitwise_and (bitwise_or x xb) (bitwise_or xa xb)"
-  by (import word32 RIGHT_OR_OVER_ANDw)
-
-lemma DE_MORGAN_THMw: "word_1comp (bitwise_and x xa) = bitwise_or (word_1comp x) (word_1comp xa) &
-word_1comp (bitwise_or x xa) = bitwise_and (word_1comp x) (word_1comp xa)"
-  by (import word32 DE_MORGAN_THMw)
-
-lemma w_0: "w_0 = n2w 0"
-  by (import word32 w_0)
-
-lemma w_1: "w_1 = n2w 1"
-  by (import word32 w_1)
-
-lemma w_T: "w_T =
-n2w (NUMERAL
-      (NUMERAL_BIT1
-        (NUMERAL_BIT1
-          (NUMERAL_BIT1
-            (NUMERAL_BIT1
-              (NUMERAL_BIT1
-                (NUMERAL_BIT1
-                  (NUMERAL_BIT1
-                    (NUMERAL_BIT1
-                      (NUMERAL_BIT1
-                        (NUMERAL_BIT1
-                          (NUMERAL_BIT1
-                            (NUMERAL_BIT1
-                              (NUMERAL_BIT1
-                                (NUMERAL_BIT1
-                                  (NUMERAL_BIT1
-                                    (NUMERAL_BIT1
-(NUMERAL_BIT1
-  (NUMERAL_BIT1
-    (NUMERAL_BIT1
-      (NUMERAL_BIT1
-        (NUMERAL_BIT1
-          (NUMERAL_BIT1
-            (NUMERAL_BIT1
-              (NUMERAL_BIT1
-                (NUMERAL_BIT1
-                  (NUMERAL_BIT1
-                    (NUMERAL_BIT1
-                      (NUMERAL_BIT1
-                        (NUMERAL_BIT1
-                          (NUMERAL_BIT1
-                            (NUMERAL_BIT1
-                              (NUMERAL_BIT1
-                                ALT_ZERO)))))))))))))))))))))))))))))))))"
-  by (import word32 w_T)
-
-lemma ADD_TWO_COMP: "word_add x (word_2comp x) = w_0"
-  by (import word32 ADD_TWO_COMP)
-
-lemma ADD_TWO_COMP2: "word_add (word_2comp x) x = w_0"
-  by (import word32 ADD_TWO_COMP2)
-
-definition
-  word_sub :: "word32 => word32 => word32"  where
-  "word_sub == %a b. word_add a (word_2comp b)"
-
-lemma word_sub: "word_sub a b = word_add a (word_2comp b)"
-  by (import word32 word_sub)
-
-definition
-  word_lsl :: "word32 => nat => word32"  where
-  "word_lsl == %a n. word_mul a (n2w (2 ^ n))"
-
-lemma word_lsl: "word_lsl a n = word_mul a (n2w (2 ^ n))"
-  by (import word32 word_lsl)
-
-definition
-  word_lsr :: "word32 => nat => word32"  where
-  "word_lsr == %a n. (word_lsr1 ^^ n) a"
-
-lemma word_lsr: "word_lsr a n = (word_lsr1 ^^ n) a"
-  by (import word32 word_lsr)
-
-definition
-  word_asr :: "word32 => nat => word32"  where
-  "word_asr == %a n. (word_asr1 ^^ n) a"
-
-lemma word_asr: "word_asr a n = (word_asr1 ^^ n) a"
-  by (import word32 word_asr)
-
-definition
-  word_ror :: "word32 => nat => word32"  where
-  "word_ror == %a n. (word_ror1 ^^ n) a"
-
-lemma word_ror: "word_ror a n = (word_ror1 ^^ n) a"
-  by (import word32 word_ror)
-
-consts
-  BITw :: "nat => word32 => bool" 
-
-defs
-  BITw_primdef: "BITw == %b n. bit b (w2n n)"
-
-lemma BITw_def: "BITw b n = bit b (w2n n)"
-  by (import word32 BITw_def)
-
-consts
-  BITSw :: "nat => nat => word32 => nat" 
-
-defs
-  BITSw_primdef: "BITSw == %h l n. BITS h l (w2n n)"
-
-lemma BITSw_def: "BITSw h l n = BITS h l (w2n n)"
-  by (import word32 BITSw_def)
-
-consts
-  SLICEw :: "nat => nat => word32 => nat" 
-
-defs
-  SLICEw_primdef: "SLICEw == %h l n. SLICE h l (w2n n)"
-
-lemma SLICEw_def: "SLICEw h l n = SLICE h l (w2n n)"
-  by (import word32 SLICEw_def)
-
-lemma TWO_COMP_ADD: "word_2comp (word_add a b) = word_add (word_2comp a) (word_2comp b)"
-  by (import word32 TWO_COMP_ADD)
-
-lemma TWO_COMP_ELIM: "word_2comp (word_2comp a) = a"
-  by (import word32 TWO_COMP_ELIM)
-
-lemma ADD_SUB_ASSOC: "word_sub (word_add a b) c = word_add a (word_sub b c)"
-  by (import word32 ADD_SUB_ASSOC)
-
-lemma ADD_SUB_SYM: "word_sub (word_add a b) c = word_add (word_sub a c) b"
-  by (import word32 ADD_SUB_SYM)
-
-lemma SUB_EQUALw: "word_sub a a = w_0"
-  by (import word32 SUB_EQUALw)
-
-lemma ADD_SUBw: "word_sub (word_add a b) b = a"
-  by (import word32 ADD_SUBw)
-
-lemma SUB_SUBw: "word_sub a (word_sub b c) = word_sub (word_add a c) b"
-  by (import word32 SUB_SUBw)
-
-lemma ONE_COMP_TWO_COMP: "word_1comp a = word_sub (word_2comp a) w_1"
-  by (import word32 ONE_COMP_TWO_COMP)
-
-lemma SUBw: "word_sub (word_suc m) n = word_suc (word_sub m n)"
-  by (import word32 SUBw)
-
-lemma ADD_EQ_SUBw: "(word_add m n = p) = (m = word_sub p n)"
-  by (import word32 ADD_EQ_SUBw)
-
-lemma CANCEL_SUBw: "(word_sub n p = word_sub m p) = (n = m)"
-  by (import word32 CANCEL_SUBw)
-
-lemma SUB_PLUSw: "word_sub a (word_add b c) = word_sub (word_sub a b) c"
-  by (import word32 SUB_PLUSw)
-
-lemma word_nchotomy: "EX n. w = n2w n"
-  by (import word32 word_nchotomy)
-
-lemma dest_word_mk_word_eq3: "dest_word32 (mk_word32 (EQUIV a)) = EQUIV a"
-  by (import word32 dest_word_mk_word_eq3)
-
-lemma MODw_ELIM: "n2w (MODw n) = n2w n"
-  by (import word32 MODw_ELIM)
-
-lemma w2n_EVAL: "w2n (n2w n) = MODw n"
-  by (import word32 w2n_EVAL)
-
-lemma w2n_ELIM: "n2w (w2n a) = a"
-  by (import word32 w2n_ELIM)
-
-lemma n2w_11: "(n2w a = n2w b) = (MODw a = MODw b)"
-  by (import word32 n2w_11)
-
-lemma ADD_EVAL: "word_add (n2w a) (n2w b) = n2w (a + b)"
-  by (import word32 ADD_EVAL)
-
-lemma MUL_EVAL: "word_mul (n2w a) (n2w b) = n2w (a * b)"
-  by (import word32 MUL_EVAL)
-
-lemma ONE_COMP_EVAL: "word_1comp (n2w a) = n2w (ONE_COMP a)"
-  by (import word32 ONE_COMP_EVAL)
-
-lemma TWO_COMP_EVAL: "word_2comp (n2w a) = n2w (TWO_COMP a)"
-  by (import word32 TWO_COMP_EVAL)
-
-lemma LSR_ONE_EVAL: "word_lsr1 (n2w a) = n2w (LSR_ONE a)"
-  by (import word32 LSR_ONE_EVAL)
-
-lemma ASR_ONE_EVAL: "word_asr1 (n2w a) = n2w (ASR_ONE a)"
-  by (import word32 ASR_ONE_EVAL)
-
-lemma ROR_ONE_EVAL: "word_ror1 (n2w a) = n2w (ROR_ONE a)"
-  by (import word32 ROR_ONE_EVAL)
-
-lemma RRX_EVAL: "RRX c (n2w a) = n2w (RRXn c a)"
-  by (import word32 RRX_EVAL)
-
-lemma LSB_EVAL: "LSB (n2w a) = LSBn a"
-  by (import word32 LSB_EVAL)
-
-lemma MSB_EVAL: "MSB (n2w a) = MSBn a"
-  by (import word32 MSB_EVAL)
-
-lemma OR_EVAL: "bitwise_or (n2w a) (n2w b) = n2w (OR a b)"
-  by (import word32 OR_EVAL)
-
-lemma EOR_EVAL: "bitwise_eor (n2w a) (n2w b) = n2w (EOR a b)"
-  by (import word32 EOR_EVAL)
-
-lemma AND_EVAL: "bitwise_and (n2w a) (n2w b) = n2w (AND a b)"
-  by (import word32 AND_EVAL)
-
-lemma BITS_EVAL: "BITSw h l (n2w a) = BITS h l (MODw a)"
-  by (import word32 BITS_EVAL)
-
-lemma BIT_EVAL: "BITw b (n2w a) = bit b (MODw a)"
-  by (import word32 BIT_EVAL)
-
-lemma SLICE_EVAL: "SLICEw h l (n2w a) = SLICE h l (MODw a)"
-  by (import word32 SLICE_EVAL)
-
-lemma LSL_ADD: "word_lsl (word_lsl a m) n = word_lsl a (m + n)"
-  by (import word32 LSL_ADD)
-
-lemma LSR_ADD: "word_lsr (word_lsr x xa) xb = word_lsr x (xa + xb)"
-  by (import word32 LSR_ADD)
-
-lemma ASR_ADD: "word_asr (word_asr x xa) xb = word_asr x (xa + xb)"
-  by (import word32 ASR_ADD)
-
-lemma ROR_ADD: "word_ror (word_ror x xa) xb = word_ror x (xa + xb)"
-  by (import word32 ROR_ADD)
-
-lemma LSL_LIMIT: "HB < n ==> word_lsl w n = w_0"
-  by (import word32 LSL_LIMIT)
-
-lemma MOD_MOD_DIV: "INw (MODw a div 2 ^ b)"
-  by (import word32 MOD_MOD_DIV)
-
-lemma MOD_MOD_DIV_2EXP: "MODw (MODw a div 2 ^ n) div 2 = MODw a div 2 ^ Suc n"
-  by (import word32 MOD_MOD_DIV_2EXP)
-
-lemma LSR_EVAL: "word_lsr (n2w a) n = n2w (MODw a div 2 ^ n)"
-  by (import word32 LSR_EVAL)
-
-lemma LSR_THM: "word_lsr (n2w n) x = n2w (BITS HB (min WL x) n)"
-  by (import word32 LSR_THM)
-
-lemma LSR_LIMIT: "HB < x ==> word_lsr w x = w_0"
-  by (import word32 LSR_LIMIT)
-
-lemma LEFT_SHIFT_LESS: "(a::nat) < (2::nat) ^ (m::nat)
-==> (2::nat) ^ (n::nat) + a * (2::nat) ^ n <= (2::nat) ^ (m + n)"
-  by (import word32 LEFT_SHIFT_LESS)
-
-lemma ROR_THM: "word_ror (n2w n) x =
-(let x' = x mod WL
- in n2w (BITS HB x' n + BITS (x' - 1) 0 n * 2 ^ (WL - x')))"
-  by (import word32 ROR_THM)
-
-lemma ROR_CYCLE: "word_ror w (x * WL) = w"
-  by (import word32 ROR_CYCLE)
-
-lemma ASR_THM: "word_asr (n2w n) x =
-(let x' = min HB x; s = BITS HB x' n
- in n2w (if MSBn n then 2 ^ WL - 2 ^ (WL - x') + s else s))"
-  by (import word32 ASR_THM)
-
-lemma ASR_LIMIT: "HB <= x ==> word_asr w x = (if MSB w then w_T else w_0)"
-  by (import word32 ASR_LIMIT)
-
-lemma ZERO_SHIFT: "(ALL n. word_lsl w_0 n = w_0) &
-(ALL n. word_asr w_0 n = w_0) &
-(ALL n. word_lsr w_0 n = w_0) & (ALL n. word_ror w_0 n = w_0)"
-  by (import word32 ZERO_SHIFT)
-
-lemma ZERO_SHIFT2: "(ALL a. word_lsl a 0 = a) &
-(ALL a. word_asr a 0 = a) &
-(ALL a. word_lsr a 0 = a) & (ALL a. word_ror a 0 = a)"
-  by (import word32 ZERO_SHIFT2)
-
-lemma ASR_w_T: "word_asr w_T n = w_T"
-  by (import word32 ASR_w_T)
-
-lemma ROR_w_T: "word_ror w_T n = w_T"
-  by (import word32 ROR_w_T)
-
-lemma MODw_EVAL: "MODw x =
-x mod
-NUMERAL
- (NUMERAL_BIT2
-   (NUMERAL_BIT1
-     (NUMERAL_BIT1
-       (NUMERAL_BIT1
-         (NUMERAL_BIT1
-           (NUMERAL_BIT1
-             (NUMERAL_BIT1
-               (NUMERAL_BIT1
-                 (NUMERAL_BIT1
-                   (NUMERAL_BIT1
-                     (NUMERAL_BIT1
-                       (NUMERAL_BIT1
-                         (NUMERAL_BIT1
-                           (NUMERAL_BIT1
-                             (NUMERAL_BIT1
-                               (NUMERAL_BIT1
-                                 (NUMERAL_BIT1
-                                   (NUMERAL_BIT1
-                                     (NUMERAL_BIT1
- (NUMERAL_BIT1
-   (NUMERAL_BIT1
-     (NUMERAL_BIT1
-       (NUMERAL_BIT1
-         (NUMERAL_BIT1
-           (NUMERAL_BIT1
-             (NUMERAL_BIT1
-               (NUMERAL_BIT1
-                 (NUMERAL_BIT1
-                   (NUMERAL_BIT1
-                     (NUMERAL_BIT1
-                       (NUMERAL_BIT1
-                         (NUMERAL_BIT1
-                           ALT_ZERO))))))))))))))))))))))))))))))))"
-  by (import word32 MODw_EVAL)
-
-lemma ADD_EVAL2: "word_add (n2w a) (n2w b) = n2w (MODw (a + b))"
-  by (import word32 ADD_EVAL2)
-
-lemma MUL_EVAL2: "word_mul (n2w a) (n2w b) = n2w (MODw (a * b))"
-  by (import word32 MUL_EVAL2)
-
-lemma ONE_COMP_EVAL2: "word_1comp (n2w a) =
-n2w (2 ^
-     NUMERAL
-      (NUMERAL_BIT2
-        (NUMERAL_BIT1
-          (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO))))) -
-     1 -
-     MODw a)"
-  by (import word32 ONE_COMP_EVAL2)
-
-lemma TWO_COMP_EVAL2: "word_2comp (n2w a) =
-n2w (MODw
-      (2 ^
-       NUMERAL
-        (NUMERAL_BIT2
-          (NUMERAL_BIT1
-            (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO))))) -
-       MODw a))"
-  by (import word32 TWO_COMP_EVAL2)
-
-lemma LSR_ONE_EVAL2: "word_lsr1 (n2w a) = n2w (MODw a div 2)"
-  by (import word32 LSR_ONE_EVAL2)
-
-lemma ASR_ONE_EVAL2: "word_asr1 (n2w a) =
-n2w (MODw a div 2 +
-     SBIT (MSBn a)
-      (NUMERAL
-        (NUMERAL_BIT1
-          (NUMERAL_BIT1
-            (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO)))))))"
-  by (import word32 ASR_ONE_EVAL2)
-
-lemma ROR_ONE_EVAL2: "word_ror1 (n2w a) =
-n2w (MODw a div 2 +
-     SBIT (LSBn a)
-      (NUMERAL
-        (NUMERAL_BIT1
-          (NUMERAL_BIT1
-            (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO)))))))"
-  by (import word32 ROR_ONE_EVAL2)
-
-lemma RRX_EVAL2: "RRX c (n2w a) =
-n2w (MODw a div 2 +
-     SBIT c
-      (NUMERAL
-        (NUMERAL_BIT1
-          (NUMERAL_BIT1
-            (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO)))))))"
-  by (import word32 RRX_EVAL2)
-
-lemma LSB_EVAL2: "LSB (n2w a) = ODD a"
-  by (import word32 LSB_EVAL2)
-
-lemma MSB_EVAL2: "MSB (n2w a) =
-bit (NUMERAL
-      (NUMERAL_BIT1
-        (NUMERAL_BIT1
-          (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO))))))
- a"
-  by (import word32 MSB_EVAL2)
-
-lemma OR_EVAL2: "bitwise_or (n2w a) (n2w b) =
-n2w (BITWISE
-      (NUMERAL
-        (NUMERAL_BIT2
-          (NUMERAL_BIT1
-            (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO))))))
-      op | a b)"
-  by (import word32 OR_EVAL2)
-
-lemma AND_EVAL2: "bitwise_and (n2w a) (n2w b) =
-n2w (BITWISE
-      (NUMERAL
-        (NUMERAL_BIT2
-          (NUMERAL_BIT1
-            (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO))))))
-      op & a b)"
-  by (import word32 AND_EVAL2)
-
-lemma EOR_EVAL2: "bitwise_eor (n2w a) (n2w b) =
-n2w (BITWISE
-      (NUMERAL
-        (NUMERAL_BIT2
-          (NUMERAL_BIT1
-            (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO))))))
-      op ~= a b)"
-  by (import word32 EOR_EVAL2)
-
-lemma BITWISE_EVAL2: "BITWISE n oper x y =
-(if n = 0 then 0
- else 2 * BITWISE (n - 1) oper (x div 2) (y div 2) +
-      (if oper (ODD x) (ODD y) then 1 else 0))"
-  by (import word32 BITWISE_EVAL2)
-
-lemma BITSwLT_THM: "BITSw h l n < 2 ^ (Suc h - l)"
-  by (import word32 BITSwLT_THM)
-
-lemma BITSw_COMP_THM: "h2 + l1 <= h1 ==> BITS h2 l2 (BITSw h1 l1 n) = BITSw (h2 + l1) (l2 + l1) n"
-  by (import word32 BITSw_COMP_THM)
-
-lemma BITSw_DIV_THM: "BITSw h l x div 2 ^ n = BITSw h (l + n) x"
-  by (import word32 BITSw_DIV_THM)
-
-lemma BITw_THM: "BITw b n = (BITSw b b n = 1)"
-  by (import word32 BITw_THM)
-
-lemma SLICEw_THM: "SLICEw h l n = BITSw h l n * 2 ^ l"
-  by (import word32 SLICEw_THM)
-
-lemma BITS_SLICEw_THM: "BITS h l (SLICEw h l n) = BITSw h l n"
-  by (import word32 BITS_SLICEw_THM)
-
-lemma SLICEw_ZERO_THM: "SLICEw h 0 n = BITSw h 0 n"
-  by (import word32 SLICEw_ZERO_THM)
-
-lemma SLICEw_COMP_THM: "Suc m <= h & l <= m ==> SLICEw h (Suc m) a + SLICEw m l a = SLICEw h l a"
-  by (import word32 SLICEw_COMP_THM)
-
-lemma BITSw_ZERO: "h < l ==> BITSw h l n = 0"
-  by (import word32 BITSw_ZERO)
-
-lemma SLICEw_ZERO: "h < l ==> SLICEw h l n = 0"
-  by (import word32 SLICEw_ZERO)
-
-;end_setup
-
-end
-
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/README
--- a/src/HOL/Import/HOL/README	Sat Mar 03 21:51:38 2012 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,20 +0,0 @@
-(*  Title:      HOL/Import/HOL/README
-    ID:         $Id$
-    Author:     Sebastian Skalberg (TU Muenchen)
-*)
-
-All the files in this directory (except this README, HOL4.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 HOL4 proofs are not consulted
-at all.  If a real replay of the HOL4 proofs is desired, get and
-unpack the HOL4 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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/ROOT.ML
--- a/src/HOL/Import/HOL/ROOT.ML	Sat Mar 03 21:51:38 2012 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,2 +0,0 @@
-use_thy "~~/src/HOL/Old_Number_Theory/Primes";
-Unsynchronized.setmp quick_and_dirty true use_thys ["HOL4Prob", "HOL4"];
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/arithmetic.imp
--- a/src/HOL/Import/HOL/arithmetic.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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" > "HOL4Compat.NUMERAL_BIT2"
-  "NUMERAL_BIT1" > "HOL4Compat.NUMERAL_BIT1"
-  "NUMERAL" > "HOL4Compat.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" > "HOL4Compat.FUNPOW"
-  "EXP" > "Power.power_class.power" :: "nat => nat => nat"
-  "DIV" > "Divides.div_class.div" :: "nat => nat => nat"
-  "ALT_ZERO" > "HOL4Compat.ALT_ZERO"
-  ">=" > "HOL4Compat.nat_ge"
-  ">" > "HOL4Compat.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" > "HOL4Compat.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" > "HOL4Compat.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" > "HOL4Compat.NUMERAL_def"
-  "NUMERAL_BIT2" > "HOL4Compat.NUMERAL_BIT2_def"
-  "NUMERAL_BIT1" > "HOL4Compat.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" > "HOL4Compat.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" > "HOL4Compat.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" > "HOL4Compat.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" > "HOL4Compat.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" > "HOL4Compat.GREATER_OR_EQ"
-  "GREATER_EQ" > "HOL4Compat.real_ge"
-  "GREATER_DEF" > "HOL4Compat.GREATER_DEF"
-  "FUN_EQ_LEMMA" > "HOL4Base.arithmetic.FUN_EQ_LEMMA"
-  "FUNPOW" > "HOL4Compat.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" > "HOL4Compat.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" > "HOL4Compat.DIVISION"
-  "DA" > "HOL4Base.arithmetic.DA"
-  "COMPLETE_INDUCTION" > "Nat.nat_less_induct"
-  "CANCEL_SUB" > "Nat.eq_diff_iff"
-  "ALT_ZERO" > "HOL4Compat.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" > "HOL4Compat.ADD"
-
-end
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/bits.imp
--- a/src/HOL/Import/HOL/bits.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/bool.imp
--- a/src/HOL/Import/HOL/bool.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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" > "HOL4Setup.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" > "HOL4Setup.ONE_ONE"
-  "LET" > "HOL4Compat.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" > "HOL4Compat.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" > "HOL4Setup.TYPE_DEFINITION"
-  "TYPE_DEFINITION" > "HOL4Setup.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" > "HOL4Setup.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" > "HOL4Setup.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" > "HOL4Compat.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" > "HOL4Setup.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" > "HOL4Compat.EXISTS_UNIQUE_DEF"
-  "EXISTS_UNIQUE_REFL" > "HOL.ex1_eq_1"
-  "EXISTS_UNIQUE_DEF" > "HOL4Compat.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" > "HOL4Setup.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" > "HOL4Compat.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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/boolean_sequence.imp
--- a/src/HOL/Import/HOL/boolean_sequence.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/bword_arith.imp
--- a/src/HOL/Import/HOL/bword_arith.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/bword_bitop.imp
--- a/src/HOL/Import/HOL/bword_bitop.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/bword_num.imp
--- a/src/HOL/Import/HOL/bword_num.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/combin.imp
--- a/src/HOL/Import/HOL/combin.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/divides.imp
--- a/src/HOL/Import/HOL/divides.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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" > "HOL4Compat.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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/hrat.imp
--- a/src/HOL/Import/HOL/hrat.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/hreal.imp
--- a/src/HOL/Import/HOL/hreal.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/ind_type.imp
--- a/src/HOL/Import/HOL/ind_type.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/lim.imp
--- a/src/HOL/Import/HOL/lim.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/list.imp
--- a/src/HOL/Import/HOL/list.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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" > "HOL4Compat.list_size"
-  "list_case" > "List.list.list_case"
-  "ZIP" > "HOL4Compat.ZIP"
-  "UNZIP" > "HOL4Compat.unzip"
-  "TL" > "List.tl"
-  "SUM" > "HOL4Compat.sum"
-  "REVERSE" > "List.rev"
-  "REPLICATE" > "List.replicate"
-  "NULL" > "List.null"
-  "NIL" > "List.list.Nil"
-  "MEM" > "HOL4Compat.list_mem"
-  "MAP2" > "HOL4Compat.map2"
-  "MAP" > "List.map"
-  "LENGTH" > "Nat.size_class.size"
-  "LAST" > "List.last"
-  "HD" > "List.hd"
-  "FRONT" > "List.butlast"
-  "FOLDR" > "HOL4Compat.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" > "HOL4Compat.list_size_def'"
-  "list_size_cong" > "HOL4Base.list.list_size_cong"
-  "list_nchotomy" > "HOL4Compat.list_CASES"
-  "list_induction" > "HOL4Compat.list_INDUCT"
-  "list_distinct" > "List.list.distinct_1"
-  "list_case_def" > "HOL4Compat.list_case_def"
-  "list_case_cong" > "HOL4Compat.list_case_cong"
-  "list_case_compute" > "HOL4Base.list.list_case_compute"
-  "list_INDUCT" > "HOL4Compat.list_INDUCT"
-  "list_CASES" > "HOL4Compat.list_CASES"
-  "list_Axiom_old" > "HOL4Compat.list_Axiom_old"
-  "list_Axiom" > "HOL4Compat.list_Axiom"
-  "list_11" > "List.list.inject"
-  "ZIP_UNZIP" > "HOL4Base.list.ZIP_UNZIP"
-  "ZIP_MAP" > "HOL4Base.list.ZIP_MAP"
-  "ZIP" > "HOL4Compat.ZIP"
-  "WF_LIST_PRED" > "HOL4Base.list.WF_LIST_PRED"
-  "UNZIP_ZIP" > "HOL4Base.list.UNZIP_ZIP"
-  "UNZIP" > "HOL4Compat.UNZIP"
-  "TL" > "List.tl.simps_2"
-  "SUM" > "HOL4Compat.SUM"
-  "REVERSE_REVERSE" > "List.rev_rev_ident"
-  "REVERSE_DEF" > "HOL4Compat.REVERSE"
-  "REVERSE_APPEND" > "List.rev_append"
-  "NULL_DEF" > "HOL4Compat.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" > "HOL4Compat.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" > "HOL4Compat.MAP2"
-  "MAP" > "HOL4Compat.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" > "HOL4Compat.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" > "HOL4Compat.FOLDR"
-  "FOLDL_CONG" > "HOL4Base.list.FOLDL_CONG"
-  "FOLDL" > "HOL4Compat.FOLDL"
-  "FLAT" > "HOL4Compat.FLAT"
-  "FILTER" > "HOL4Compat.FILTER"
-  "EXISTS_MEM" > "HOL4Base.list.EXISTS_MEM"
-  "EXISTS_DEF" > "HOL4Compat.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" > "HOL4Compat.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" > "HOL4Compat.APPEND"
-
-ignore_thms
-  "list_repfns"
-  "list_TY_DEF"
-  "list1_def"
-  "list0_def"
-  "NIL"
-  "CONS_def"
-
-end
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/marker.imp
--- a/src/HOL/Import/HOL/marker.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/nets.imp
--- a/src/HOL/Import/HOL/nets.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/num.imp
--- a/src/HOL/Import/HOL/num.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/numeral.imp
--- a/src/HOL/Import/HOL/numeral.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/one.imp
--- a/src/HOL/Import/HOL/one.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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" > "HOL4Compat.one"
-
-ignore_thms
-  "one_axiom"
-  "one_TY_DEF"
-  "one_DEF"
-  "one_Axiom"
-
-end
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/operator.imp
--- a/src/HOL/Import/HOL/operator.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/option.imp
--- a/src/HOL/Import/HOL/option.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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" > "HOL4Compat.OPTION_JOIN"
-  "NONE" > "Option.option.None"
-  "IS_SOME" > "HOL4Compat.IS_SOME"
-  "IS_NONE" > "HOL4Compat.IS_NONE"
-
-thm_maps
-  "option_nchotomy" > "Option.option.nchotomy"
-  "option_induction" > "Option.option.induct"
-  "option_case_def" > "HOL4Compat.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" > "HOL4Compat.OPTION_MAP_DEF"
-  "OPTION_JOIN_EQ_SOME" > "HOL4Base.option.OPTION_JOIN_EQ_SOME"
-  "OPTION_JOIN_DEF" > "HOL4Compat.OPTION_JOIN_DEF"
-  "NOT_SOME_NONE" > "Option.option.distinct_2"
-  "NOT_NONE_SOME" > "Option.option.distinct_1"
-  "IS_SOME_DEF" > "HOL4Compat.IS_SOME_DEF"
-  "IS_NONE_DEF" > "HOL4Compat.IS_NONE_DEF"
-
-ignore_thms
-  "option_axiom"
-  "option_TY_DEF"
-  "option_REP_ABS_DEF"
-  "option_Axiom"
-  "SOME_DEF"
-  "NONE_DEF"
-
-end
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/pair.imp
--- a/src/HOL/Import/HOL/pair.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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" > "HOL4Compat.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" > "HOL4Compat.PAIR_MAP"
-  "PAIR_EQ" > "Product_Type.Pair_eq"
-  "PAIR" > "HOL4Compat.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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/poly.imp
--- a/src/HOL/Import/HOL/poly.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/powser.imp
--- a/src/HOL/Import/HOL/powser.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/pred_set.imp
--- a/src/HOL/Import/HOL/pred_set.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/prim_rec.imp
--- a/src/HOL/Import/HOL/prim_rec.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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" > "HOL4Compat.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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/prime.imp
--- a/src/HOL/Import/HOL/prime.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/prob.imp
--- a/src/HOL/Import/HOL/prob.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/prob_algebra.imp
--- a/src/HOL/Import/HOL/prob_algebra.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/prob_canon.imp
--- a/src/HOL/Import/HOL/prob_canon.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/prob_extra.imp
--- a/src/HOL/Import/HOL/prob_extra.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/prob_indep.imp
--- a/src/HOL/Import/HOL/prob_indep.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/prob_pseudo.imp
--- a/src/HOL/Import/HOL/prob_pseudo.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/prob_uniform.imp
--- a/src/HOL/Import/HOL/prob_uniform.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/real.imp
--- a/src/HOL/Import/HOL/real.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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" > "HOL4Compat.real_gt"
-  "real_ge" > "HOL4Compat.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" > "HOL4Compat.real_of_num"
-  "real_lte" > "HOL4Compat.real_lte"
-  "real_lt" > "Orderings.linorder_class.not_le"
-  "real_gt" > "HOL4Compat.GREATER_DEF"
-  "real_ge" > "HOL4Compat.real_ge"
-  "real_div" > "Fields.division_ring_class.divide_inverse"
-  "pow" > "HOL4Compat.pow"
-  "abs" > "HOL4Compat.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" > "HOL4Compat.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" > "HOL4Compat.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" > "HOL4Compat.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" > "HOL4Compat.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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/realax.imp
--- a/src/HOL/Import/HOL/realax.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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" > "HOL4Compat.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" > "HOL4Compat.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" > "HOL4Compat.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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/relation.imp
--- a/src/HOL/Import/HOL/relation.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/res_quan.imp
--- a/src/HOL/Import/HOL/res_quan.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/rich_list.imp
--- a/src/HOL/Import/HOL/rich_list.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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" > "HOL4Compat.list_INDUCT"
-  "list_CASES" > "HOL4Compat.list_CASES"
-  "ZIP_UNZIP" > "HOL4Base.list.ZIP_UNZIP"
-  "ZIP_SNOC" > "HOL4Base.rich_list.ZIP_SNOC"
-  "ZIP" > "HOL4Compat.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" > "HOL4Compat.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" > "HOL4Compat.sum_def"
-  "SUM_FOLDL" > "HOL4Base.rich_list.SUM_FOLDL"
-  "SUM_FLAT" > "HOL4Base.rich_list.SUM_FLAT"
-  "SUM_APPEND" > "HOL4Base.rich_list.SUM_APPEND"
-  "SUM" > "HOL4Compat.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" > "HOL4Compat.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" > "HOL4Compat.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" > "HOL4Compat.MAP2"
-  "MAP" > "HOL4Compat.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" > "HOL4Compat.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" > "HOL4Compat.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" > "HOL4Compat.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" > "HOL4Compat.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" > "HOL4Compat.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" > "HOL4Compat.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" > "HOL4Compat.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" > "HOL4Compat.EVERY_DEF"
-
-end
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/seq.imp
--- a/src/HOL/Import/HOL/seq.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/state_transformer.imp
--- a/src/HOL/Import/HOL/state_transformer.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/sum.imp
--- a/src/HOL/Import/HOL/sum.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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" > "HOL4Compat.OUTR"
-  "OUTL" > "HOL4Compat.OUTL"
-  "ISR" > "HOL4Compat.ISR"
-  "ISL" > "HOL4Compat.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" > "HOL4Compat.sum_case_def"
-  "sum_case_cong" > "HOL4Base.sum.sum_case_cong"
-  "sum_axiom" > "HOL4Compat.sum_axiom"
-  "sum_INDUCT" > "Sum_Type.sum.induct"
-  "sum_CASES" > "Sum_Type.sum.nchotomy"
-  "OUTR" > "HOL4Compat.OUTR"
-  "OUTL" > "HOL4Compat.OUTL"
-  "ISR" > "HOL4Compat.ISR"
-  "ISL_OR_ISR" > "HOL4Base.sum.ISL_OR_ISR"
-  "ISL" > "HOL4Compat.ISL"
-  "INR_neq_INL" > "Sum_Type.Inr_not_Inl"
-  "INR_INL_11" > "HOL4Compat.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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/topology.imp
--- a/src/HOL/Import/HOL/topology.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/transc.imp
--- a/src/HOL/Import/HOL/transc.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/word32.imp
--- a/src/HOL/Import/HOL/word32.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/word_base.imp
--- a/src/HOL/Import/HOL/word_base.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/word_bitop.imp
--- a/src/HOL/Import/HOL/word_bitop.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL/word_num.imp
--- a/src/HOL/Import/HOL/word_num.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/HOL4Base.thy
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/HOL4Base.thy	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,4501 @@
+(* AUTOMATICALLY GENERATED, DO NOT EDIT! *)
+
+theory HOL4Base
+imports "../../HOL4Syntax" "../Compatibility"
+begin
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" bool
+
+definition
+  ARB :: "'a"  where
+  "ARB == SOME x. True"
+
+lemma ARB_DEF: "ARB = (SOME x. True)"
+  sorry
+
+definition
+  IN :: "'a => ('a => bool) => bool"  where
+  "IN == %x f. f x"
+
+lemma IN_DEF: "IN = (%x f. f x)"
+  sorry
+
+definition
+  RES_FORALL :: "('a => bool) => ('a => bool) => bool"  where
+  "RES_FORALL == %p m. ALL x. IN x p --> m x"
+
+lemma RES_FORALL_DEF: "RES_FORALL = (%p m. ALL x. IN x p --> m x)"
+  sorry
+
+definition
+  RES_EXISTS :: "('a => bool) => ('a => bool) => bool"  where
+  "RES_EXISTS == %p m. EX x. IN x p & m x"
+
+lemma RES_EXISTS_DEF: "RES_EXISTS = (%p m. EX x. IN x p & m x)"
+  sorry
+
+definition
+  RES_EXISTS_UNIQUE :: "('a => bool) => ('a => bool) => bool"  where
+  "RES_EXISTS_UNIQUE ==
+%p m. RES_EXISTS p m &
+      RES_FORALL p (%x. RES_FORALL p (%y. m x & m y --> x = y))"
+
+lemma RES_EXISTS_UNIQUE_DEF: "RES_EXISTS_UNIQUE =
+(%p m. RES_EXISTS p m &
+       RES_FORALL p (%x. RES_FORALL p (%y. m x & m y --> x = y)))"
+  sorry
+
+definition
+  RES_SELECT :: "('a => bool) => ('a => bool) => 'a"  where
+  "RES_SELECT == %p m. SOME x. IN x p & m x"
+
+lemma RES_SELECT_DEF: "RES_SELECT = (%p m. SOME x. IN x p & m x)"
+  sorry
+
+lemma EXCLUDED_MIDDLE: "t | ~ t"
+  sorry
+
+lemma FORALL_THM: "All f = All f"
+  sorry
+
+lemma EXISTS_THM: "Ex f = Ex f"
+  sorry
+
+lemma F_IMP: "[| ~ t; t |] ==> False"
+  sorry
+
+lemma NOT_AND: "~ (t & ~ t)"
+  sorry
+
+lemma AND_CLAUSES: "(True & t) = t &
+(t & True) = t & (False & t) = False & (t & False) = False & (t & t) = t"
+  sorry
+
+lemma OR_CLAUSES: "(True | t) = True &
+(t | True) = True & (False | t) = t & (t | False) = t & (t | t) = t"
+  sorry
+
+lemma IMP_CLAUSES: "(True --> t) = t &
+(t --> True) = True &
+(False --> t) = True & (t --> t) = True & (t --> False) = (~ t)"
+  sorry
+
+lemma NOT_CLAUSES: "(ALL t. (~ ~ t) = t) & (~ True) = False & (~ False) = True"
+  sorry
+
+lemma BOOL_EQ_DISTINCT: "True ~= False & False ~= True"
+  sorry
+
+lemma EQ_CLAUSES: "(True = t) = t & (t = True) = t & (False = t) = (~ t) & (t = False) = (~ t)"
+  sorry
+
+lemma COND_CLAUSES: "(if True then t1 else t2) = t1 & (if False then t1 else t2) = t2"
+  sorry
+
+lemma SELECT_UNIQUE: "(!!y. P y = (y = x)) ==> Eps P = x"
+  sorry
+
+lemma BOTH_EXISTS_AND_THM: "(EX x::'a. (P::bool) & (Q::bool)) = ((EX x::'a. P) & (EX x::'a. Q))"
+  sorry
+
+lemma BOTH_FORALL_OR_THM: "(ALL x::'a. (P::bool) | (Q::bool)) = ((ALL x::'a. P) | (ALL x::'a. Q))"
+  sorry
+
+lemma BOTH_FORALL_IMP_THM: "(ALL x::'a. (P::bool) --> (Q::bool)) = ((EX x::'a. P) --> (ALL x::'a. Q))"
+  sorry
+
+lemma BOTH_EXISTS_IMP_THM: "(EX x::'a. (P::bool) --> (Q::bool)) = ((ALL x::'a. P) --> (EX x::'a. Q))"
+  sorry
+
+lemma OR_IMP_THM: "(A = (B | A)) = (B --> A)"
+  sorry
+
+lemma DE_MORGAN_THM: "(~ (A & B)) = (~ A | ~ B) & (~ (A | B)) = (~ A & ~ B)"
+  sorry
+
+lemma IMP_F_EQ_F: "(t --> False) = (t = False)"
+  sorry
+
+lemma COND_RATOR: "(if b::bool then f::'a => 'b else (g::'a => 'b)) (x::'a) =
+(if b then f x else g x)"
+  sorry
+
+lemma COND_ABS: "(%x. if b then f x else g x) = (if b then f else g)"
+  sorry
+
+lemma COND_EXPAND: "(if b then t1 else t2) = ((~ b | t1) & (b | t2))"
+  sorry
+
+lemma ONE_ONE_THM: "inj f = (ALL x1 x2. f x1 = f x2 --> x1 = x2)"
+  sorry
+
+lemma ABS_REP_THM: "(op ==>::prop => prop => prop)
+ ((Trueprop::bool => prop)
+   ((Ex::(('b::type => 'a::type) => bool) => bool)
+     ((TYPE_DEFINITION::('a::type => bool)
+                        => ('b::type => 'a::type) => bool)
+       (P::'a::type => bool))))
+ ((Trueprop::bool => prop)
+   ((Ex::(('b::type => 'a::type) => bool) => bool)
+     (%x::'b::type => 'a::type.
+         (Ex::(('a::type => 'b::type) => bool) => bool)
+          (%abs::'a::type => 'b::type.
+              (op &::bool => bool => bool)
+               ((All::('b::type => bool) => bool)
+                 (%a::'b::type.
+                     (op =::'b::type => 'b::type => bool) (abs (x a)) a))
+               ((All::('a::type => bool) => bool)
+                 (%r::'a::type.
+                     (op =::bool => bool => bool) (P r)
+                      ((op =::'a::type => 'a::type => bool) (x (abs r))
+                        r)))))))"
+  sorry
+
+lemma LET_RAND: "(P::'b => bool) (Let (M::'a) (N::'a => 'b)) = (let x::'a = M in P (N x))"
+  sorry
+
+lemma LET_RATOR: "Let (M::'a) (N::'a => 'b => 'c) (b::'b) = (let x::'a = M in N x b)"
+  sorry
+
+lemma AND_CONG: "(Q --> P = P') & (P' --> Q = Q') ==> (P & Q) = (P' & Q')"
+  sorry
+
+lemma OR_CONG: "(~ Q --> P = P') & (~ P' --> Q = Q') ==> (P | Q) = (P' | Q')"
+  sorry
+
+lemma COND_CONG: "P = Q & (Q --> x = x') & (~ Q --> y = y')
+==> (if P then x else y) = (if Q then x' else y')"
+  sorry
+
+lemma MONO_COND: "[| x ==> y; z ==> w; if b then x else z |] ==> if b then y else w"
+  sorry
+
+lemma SKOLEM_THM: "(ALL x. Ex (P x)) = (EX f. ALL x. P x (f x))"
+  sorry
+
+lemma bool_case_thm: "(ALL (e0::'a) e1::'a. (case True of True => e0 | False => e1) = e0) &
+(ALL (e0::'a) e1::'a. (case False of True => e0 | False => e1) = e1)"
+  sorry
+
+lemma bool_case_ID: "(case b of True => x | _ => x) = x"
+  sorry
+
+lemma boolAxiom: "EX x. x True = e0 & x False = e1"
+  sorry
+
+lemma UEXISTS_OR_THM: "EX! x. P x | Q x ==> Ex1 P | Ex1 Q"
+  sorry
+
+lemma UEXISTS_SIMP: "(EX! x::'a. (t::bool)) = (t & (ALL x::'a. All (op = x)))"
+  sorry
+
+consts
+  RES_ABSTRACT :: "('a => bool) => ('a => 'b) => 'a => 'b" 
+
+specification (RES_ABSTRACT) RES_ABSTRACT_DEF: "(ALL (p::'a => bool) (m::'a => 'b) x::'a.
+    IN x p --> RES_ABSTRACT p m x = m x) &
+(ALL (p::'a => bool) (m1::'a => 'b) m2::'a => 'b.
+    (ALL x::'a. IN x p --> m1 x = m2 x) -->
+    RES_ABSTRACT p m1 = RES_ABSTRACT p m2)"
+  sorry
+
+lemma BOOL_FUN_CASES_THM: "f = (%b. True) | f = (%b. False) | f = (%b. b) | f = Not"
+  sorry
+
+lemma BOOL_FUN_INDUCT: "P (%b. True) & P (%b. False) & P (%b. b) & P Not ==> P x"
+  sorry
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" combin
+
+definition
+  K :: "'a => 'b => 'a"  where
+  "K == %x y. x"
+
+lemma K_DEF: "K = (%x y. x)"
+  sorry
+
+definition
+  S :: "('a => 'b => 'c) => ('a => 'b) => 'a => 'c"  where
+  "S == %f g x. f x (g x)"
+
+lemma S_DEF: "S = (%f g x. f x (g x))"
+  sorry
+
+definition
+  I :: "'a => 'a"  where
+  "(op ==::('a::type => 'a::type) => ('a::type => 'a::type) => prop)
+ (I::'a::type => 'a::type)
+ ((S::('a::type => ('a::type => 'a::type) => 'a::type)
+      => ('a::type => 'a::type => 'a::type) => 'a::type => 'a::type)
+   (K::'a::type => ('a::type => 'a::type) => 'a::type)
+   (K::'a::type => 'a::type => 'a::type))"
+
+lemma I_DEF: "(op =::('a::type => 'a::type) => ('a::type => 'a::type) => bool)
+ (I::'a::type => 'a::type)
+ ((S::('a::type => ('a::type => 'a::type) => 'a::type)
+      => ('a::type => 'a::type => 'a::type) => 'a::type => 'a::type)
+   (K::'a::type => ('a::type => 'a::type) => 'a::type)
+   (K::'a::type => 'a::type => 'a::type))"
+  sorry
+
+definition
+  C :: "('a => 'b => 'c) => 'b => 'a => 'c"  where
+  "C == %f x y. f y x"
+
+lemma C_DEF: "C = (%f x y. f y x)"
+  sorry
+
+definition
+  W :: "('a => 'a => 'b) => 'a => 'b"  where
+  "W == %f x. f x x"
+
+lemma W_DEF: "W = (%f x. f x x)"
+  sorry
+
+lemma I_THM: "I x = x"
+  sorry
+
+lemma I_o_ID: "I o f = f & f o I = f"
+  sorry
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" sum
+
+lemma ISL_OR_ISR: "ISL x | ISR x"
+  sorry
+
+lemma INL: "ISL x ==> Inl (OUTL x) = x"
+  sorry
+
+lemma INR: "ISR x ==> Inr (OUTR x) = x"
+  sorry
+
+lemma sum_case_cong: "(M::'b + 'c) = (M'::'b + 'c) &
+(ALL x::'b. M' = Inl x --> (f::'b => 'a) x = (f'::'b => 'a) x) &
+(ALL y::'c. M' = Inr y --> (g::'c => 'a) y = (g'::'c => 'a) y)
+==> sum_case f g M = sum_case f' g' M'"
+  sorry
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" one
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" option
+
+lemma option_CLAUSES: "(op &::bool => bool => bool)
+ ((All::('a::type => bool) => bool)
+   (%x::'a::type.
+       (All::('a::type => bool) => bool)
+        (%y::'a::type.
+            (op =::bool => bool => bool)
+             ((op =::'a::type option => 'a::type option => bool)
+               ((Some::'a::type => 'a::type option) x)
+               ((Some::'a::type => 'a::type option) y))
+             ((op =::'a::type => 'a::type => bool) x y))))
+ ((op &::bool => bool => bool)
+   ((All::('a::type => bool) => bool)
+     (%x::'a::type.
+         (op =::'a::type => 'a::type => bool)
+          ((the::'a::type option => 'a::type)
+            ((Some::'a::type => 'a::type option) x))
+          x))
+   ((op &::bool => bool => bool)
+     ((All::('a::type => bool) => bool)
+       (%x::'a::type.
+           (op ~=::'a::type option => 'a::type option => bool)
+            (None::'a::type option)
+            ((Some::'a::type => 'a::type option) x)))
+     ((op &::bool => bool => bool)
+       ((All::('a::type => bool) => bool)
+         (%x::'a::type.
+             (op ~=::'a::type option => 'a::type option => bool)
+              ((Some::'a::type => 'a::type option) x)
+              (None::'a::type option)))
+       ((op &::bool => bool => bool)
+         ((All::('a::type => bool) => bool)
+           (%x::'a::type.
+               (op =::bool => bool => bool)
+                ((IS_SOME::'a::type option => bool)
+                  ((Some::'a::type => 'a::type option) x))
+                (True::bool)))
+         ((op &::bool => bool => bool)
+           ((op =::bool => bool => bool)
+             ((IS_SOME::'a::type option => bool) (None::'a::type option))
+             (False::bool))
+           ((op &::bool => bool => bool)
+             ((All::('a::type option => bool) => bool)
+               (%x::'a::type option.
+                   (op =::bool => bool => bool)
+                    ((IS_NONE::'a::type option => bool) x)
+                    ((op =::'a::type option => 'a::type option => bool) x
+                      (None::'a::type option))))
+             ((op &::bool => bool => bool)
+               ((All::('a::type option => bool) => bool)
+                 (%x::'a::type option.
+                     (op =::bool => bool => bool)
+                      ((Not::bool => bool)
+                        ((IS_SOME::'a::type option => bool) x))
+                      ((op =::'a::type option => 'a::type option => bool) x
+                        (None::'a::type option))))
+               ((op &::bool => bool => bool)
+                 ((All::('a::type option => bool) => bool)
+                   (%x::'a::type option.
+                       (op -->::bool => bool => bool)
+                        ((IS_SOME::'a::type option => bool) x)
+                        ((op =::'a::type option => 'a::type option => bool)
+                          ((Some::'a::type => 'a::type option)
+                            ((the::'a::type option => 'a::type) x))
+                          x)))
+                 ((op &::bool => bool => bool)
+                   ((All::('a::type option => bool) => bool)
+                     (%x::'a::type option.
+                         (op =::'a::type option => 'a::type option => bool)
+                          ((option_case::'a::type option
+   => ('a::type => 'a::type option) => 'a::type option => 'a::type option)
+                            (None::'a::type option)
+                            (Some::'a::type => 'a::type option) x)
+                          x))
+                   ((op &::bool => bool => bool)
+                     ((All::('a::type option => bool) => bool)
+                       (%x::'a::type option.
+                           (op =::'a::type option
+                                  => 'a::type option => bool)
+                            ((option_case::'a::type option
+     => ('a::type => 'a::type option) => 'a::type option => 'a::type option)
+                              x (Some::'a::type => 'a::type option) x)
+                            x))
+                     ((op &::bool => bool => bool)
+                       ((All::('a::type option => bool) => bool)
+                         (%x::'a::type option.
+                             (op -->::bool => bool => bool)
+                              ((IS_NONE::'a::type option => bool) x)
+                              ((op =::'b::type => 'b::type => bool)
+                                ((option_case::'b::type
+         => ('a::type => 'b::type) => 'a::type option => 'b::type)
+                                  (e::'b::type) (f::'a::type => 'b::type) x)
+                                e)))
+                       ((op &::bool => bool => bool)
+                         ((All::('a::type option => bool) => bool)
+                           (%x::'a::type option.
+                               (op -->::bool => bool => bool)
+                                ((IS_SOME::'a::type option => bool) x)
+                                ((op =::'b::type => 'b::type => bool)
+                                  ((option_case::'b::type
+           => ('a::type => 'b::type) => 'a::type option => 'b::type)
+                                    e f x)
+                                  (f ((the::'a::type option => 'a::type)
+ x)))))
+                         ((op &::bool => bool => bool)
+                           ((All::('a::type option => bool) => bool)
+                             (%x::'a::type option.
+                                 (op -->::bool => bool => bool)
+                                  ((IS_SOME::'a::type option => bool) x)
+                                  ((op =::'a::type option
+    => 'a::type option => bool)
+                                    ((option_case::'a::type option
+             => ('a::type => 'a::type option)
+                => 'a::type option => 'a::type option)
+(ea::'a::type option) (Some::'a::type => 'a::type option) x)
+                                    x)))
+                           ((op &::bool => bool => bool)
+                             ((All::('b::type => bool) => bool)
+                               (%u::'b::type.
+                                   (All::(('a::type => 'b::type) => bool)
+   => bool)
+                                    (%f::'a::type => 'b::type.
+  (op =::'b::type => 'b::type => bool)
+   ((option_case::'b::type
+                  => ('a::type => 'b::type) => 'a::type option => 'b::type)
+     u f (None::'a::type option))
+   u)))
+                             ((op &::bool => bool => bool)
+                               ((All::('b::type => bool) => bool)
+                                 (%u::'b::type.
+                                     (All::(('a::type => 'b::type) => bool)
+     => bool)
+(%f::'a::type => 'b::type.
+    (All::('a::type => bool) => bool)
+     (%x::'a::type.
+         (op =::'b::type => 'b::type => bool)
+          ((option_case::'b::type
+                         => ('a::type => 'b::type)
+                            => 'a::type option => 'b::type)
+            u f ((Some::'a::type => 'a::type option) x))
+          (f x)))))
+                               ((op &::bool => bool => bool)
+                                 ((All::(('a::type => 'b::type) => bool)
+  => bool)
+                                   (%f::'a::type => 'b::type.
+ (All::('a::type => bool) => bool)
+  (%x::'a::type.
+      (op =::'b::type option => 'b::type option => bool)
+       ((Option.map::('a::type => 'b::type)
+                     => 'a::type option => 'b::type option)
+         f ((Some::'a::type => 'a::type option) x))
+       ((Some::'b::type => 'b::type option) (f x)))))
+                                 ((op &::bool => bool => bool)
+                                   ((All::(('a::type => 'b::type) => bool)
+    => bool)
+                                     (%f::'a::type => 'b::type.
+   (op =::'b::type option => 'b::type option => bool)
+    ((Option.map::('a::type => 'b::type)
+                  => 'a::type option => 'b::type option)
+      f (None::'a::type option))
+    (None::'b::type option)))
+                                   ((op &::bool => bool => bool)
+                                     ((op =::'a::type option
+       => 'a::type option => bool)
+ ((OPTION_JOIN::'a::type option option => 'a::type option)
+   (None::'a::type option option))
+ (None::'a::type option))
+                                     ((All::('a::type option => bool)
+      => bool)
+ (%x::'a::type option.
+     (op =::'a::type option => 'a::type option => bool)
+      ((OPTION_JOIN::'a::type option option => 'a::type option)
+        ((Some::'a::type option => 'a::type option option) x))
+      x))))))))))))))))))))"
+  sorry
+
+lemma option_case_compute: "option_case (e::'b) (f::'a => 'b) (x::'a option) =
+(if IS_SOME x then f (the x) else e)"
+  sorry
+
+lemma OPTION_MAP_EQ_SOME: "(Option.map (f::'a => 'b) (x::'a option) = Some (y::'b)) =
+(EX z::'a. x = Some z & y = f z)"
+  sorry
+
+lemma OPTION_JOIN_EQ_SOME: "(OPTION_JOIN x = Some xa) = (x = Some (Some xa))"
+  sorry
+
+lemma option_case_cong: "M = M' & (M' = None --> u = u') & (ALL x. M' = Some x --> f x = f' x)
+==> option_case u f M = option_case u' f' M'"
+  sorry
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" marker
+
+consts
+  stmarker :: "'a => 'a" 
+
+defs
+  stmarker_primdef: "stmarker == %x. x"
+
+lemma stmarker_def: "stmarker x = x"
+  sorry
+
+lemma move_left_conj: "(x & stmarker xb) = (stmarker xb & x) &
+((stmarker xb & x) & xa) = (stmarker xb & x & xa) &
+(x & stmarker xb & xa) = (stmarker xb & x & xa)"
+  sorry
+
+lemma move_right_conj: "(stmarker xb & x) = (x & stmarker xb) &
+(x & xa & stmarker xb) = ((x & xa) & stmarker xb) &
+((x & stmarker xb) & xa) = ((x & xa) & stmarker xb)"
+  sorry
+
+lemma move_left_disj: "(x | stmarker xb) = (stmarker xb | x) &
+((stmarker xb | x) | xa) = (stmarker xb | x | xa) &
+(x | stmarker xb | xa) = (stmarker xb | x | xa)"
+  sorry
+
+lemma move_right_disj: "(stmarker xb | x) = (x | stmarker xb) &
+(x | xa | stmarker xb) = ((x | xa) | stmarker xb) &
+((x | stmarker xb) | xa) = ((x | xa) | stmarker xb)"
+  sorry
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" relation
+
+definition
+  TC :: "('a => 'a => bool) => 'a => 'a => bool"  where
+  "TC ==
+%R a b.
+   ALL P.
+      (ALL x y. R x y --> P x y) & (ALL x y z. P x y & P y z --> P x z) -->
+      P a b"
+
+lemma TC_DEF: "TC R a b =
+(ALL P.
+    (ALL x y. R x y --> P x y) & (ALL x y z. P x y & P y z --> P x z) -->
+    P a b)"
+  sorry
+
+definition
+  RTC :: "('a => 'a => bool) => 'a => 'a => bool"  where
+  "RTC ==
+%R a b.
+   ALL P. (ALL x. P x x) & (ALL x y z. R x y & P y z --> P x z) --> P a b"
+
+lemma RTC_DEF: "RTC R a b =
+(ALL P. (ALL x. P x x) & (ALL x y z. R x y & P y z --> P x z) --> P a b)"
+  sorry
+
+consts
+  RC :: "('a => 'a => bool) => 'a => 'a => bool" 
+
+defs
+  RC_primdef: "RC == %R x y. x = y | R x y"
+
+lemma RC_def: "RC R x y = (x = y | R x y)"
+  sorry
+
+consts
+  transitive :: "('a => 'a => bool) => bool" 
+
+defs
+  transitive_primdef: "transitive == %R. ALL x y z. R x y & R y z --> R x z"
+
+lemma transitive_def: "transitive R = (ALL x y z. R x y & R y z --> R x z)"
+  sorry
+
+definition
+  pred_reflexive :: "('a => 'a => bool) => bool"  where
+  "pred_reflexive == %R. ALL x. R x x"
+
+lemma reflexive_def: "pred_reflexive R = (ALL x. R x x)"
+  sorry
+
+lemma TC_TRANSITIVE: "transitive (TC x)"
+  sorry
+
+lemma RTC_INDUCT: "[| (ALL x. xa x x) & (ALL xb y z. x xb y & xa y z --> xa xb z);
+   RTC x xb xc |]
+==> xa xb xc"
+  sorry
+
+lemma TC_RULES: "(ALL xa xb. x xa xb --> TC x xa xb) &
+(ALL xa xb xc. TC x xa xb & TC x xb xc --> TC x xa xc)"
+  sorry
+
+lemma RTC_RULES: "(ALL xa. RTC x xa xa) &
+(ALL xa xb xc. x xa xb & RTC x xb xc --> RTC x xa xc)"
+  sorry
+
+lemma RTC_STRONG_INDUCT: "[| (ALL x. P x x) & (ALL x y z. R x y & RTC R y z & P y z --> P x z);
+   RTC R x y |]
+==> P x y"
+  sorry
+
+lemma RTC_RTC: "[| RTC R x y; RTC R y z |] ==> RTC R x z"
+  sorry
+
+lemma RTC_TRANSITIVE: "transitive (RTC x)"
+  sorry
+
+lemma RTC_REFLEXIVE: "pred_reflexive (RTC R)"
+  sorry
+
+lemma RC_REFLEXIVE: "pred_reflexive (RC R)"
+  sorry
+
+lemma TC_SUBSET: "x xa xb ==> TC x xa xb"
+  sorry
+
+lemma RTC_SUBSET: "R x y ==> RTC R x y"
+  sorry
+
+lemma RC_SUBSET: "R x y ==> RC R x y"
+  sorry
+
+lemma RC_RTC: "RC R x y ==> RTC R x y"
+  sorry
+
+lemma TC_INDUCT: "[| (ALL xb y. x xb y --> xa xb y) & (ALL x y z. xa x y & xa y z --> xa x z);
+   TC x xb xc |]
+==> xa xb xc"
+  sorry
+
+lemma TC_INDUCT_LEFT1: "[| (ALL xb y. x xb y --> xa xb y) &
+   (ALL xb y z. x xb y & xa y z --> xa xb z);
+   TC x xb xc |]
+==> xa xb xc"
+  sorry
+
+lemma TC_STRONG_INDUCT: "[| (ALL x y. R x y --> P x y) &
+   (ALL x y z. P x y & P y z & TC R x y & TC R y z --> P x z);
+   TC R u v |]
+==> P u v"
+  sorry
+
+lemma TC_STRONG_INDUCT_LEFT1: "[| (ALL x y. R x y --> P x y) &
+   (ALL x y z. R x y & P y z & TC R y z --> P x z);
+   TC R u v |]
+==> P u v"
+  sorry
+
+lemma TC_RTC: "TC R x y ==> RTC R x y"
+  sorry
+
+lemma RTC_TC_RC: "RTC R x y ==> RC R x y | TC R x y"
+  sorry
+
+lemma TC_RC_EQNS: "RC (TC R) = RTC R & TC (RC R) = RTC R"
+  sorry
+
+lemma RC_IDEM: "RC (RC R) = RC R"
+  sorry
+
+lemma TC_IDEM: "TC (TC R) = TC R"
+  sorry
+
+lemma RTC_IDEM: "RTC (RTC R) = RTC R"
+  sorry
+
+lemma RTC_CASES1: "RTC x xa xb = (xa = xb | (EX u. x xa u & RTC x u xb))"
+  sorry
+
+lemma RTC_CASES2: "RTC x xa xb = (xa = xb | (EX u. RTC x xa u & x u xb))"
+  sorry
+
+lemma RTC_CASES_RTC_TWICE: "RTC x xa xb = (EX u. RTC x xa u & RTC x u xb)"
+  sorry
+
+lemma TC_CASES1: "TC R x z ==> R x z | (EX y. R x y & TC R y z)"
+  sorry
+
+lemma TC_CASES2: "TC R x z ==> R x z | (EX y. TC R x y & R y z)"
+  sorry
+
+lemma TC_MONOTONE: "[| !!x y. R x y ==> Q x y; TC R x y |] ==> TC Q x y"
+  sorry
+
+lemma RTC_MONOTONE: "[| !!x y. R x y ==> Q x y; RTC R x y |] ==> RTC Q x y"
+  sorry
+
+definition
+  WF :: "('a => 'a => bool) => bool"  where
+  "WF == %R. ALL B. Ex B --> (EX min. B min & (ALL b. R b min --> ~ B b))"
+
+lemma WF_DEF: "WF R = (ALL B. Ex B --> (EX min. B min & (ALL b. R b min --> ~ B b)))"
+  sorry
+
+lemma WF_INDUCTION_THM: "[| WF R; !!x. (!!y. R y x ==> P y) ==> P x |] ==> P x"
+  sorry
+
+lemma WF_NOT_REFL: "[| WF x; x xa xb |] ==> xa ~= xb"
+  sorry
+
+definition
+  EMPTY_REL :: "'a => 'a => bool"  where
+  "EMPTY_REL == %x y. False"
+
+lemma EMPTY_REL_DEF: "EMPTY_REL x y = False"
+  sorry
+
+lemma WF_EMPTY_REL: "WF EMPTY_REL"
+  sorry
+
+lemma WF_SUBSET: "WF x & (ALL xb y. xa xb y --> x xb y) ==> WF xa"
+  sorry
+
+lemma WF_TC: "WF R ==> WF (TC R)"
+  sorry
+
+consts
+  inv_image :: "('b => 'b => bool) => ('a => 'b) => 'a => 'a => bool" 
+
+defs
+  inv_image_primdef: "relation.inv_image ==
+%(R::'b => 'b => bool) (f::'a => 'b) (x::'a) y::'a. R (f x) (f y)"
+
+lemma inv_image_def: "relation.inv_image R f = (%x y. R (f x) (f y))"
+  sorry
+
+lemma WF_inv_image: "WF (R::'b => 'b => bool) ==> WF (relation.inv_image R (f::'a => 'b))"
+  sorry
+
+definition
+  RESTRICT :: "('a => 'b) => ('a => 'a => bool) => 'a => 'a => 'b"  where
+  "RESTRICT == %f R x y. if R y x then f y else ARB"
+
+lemma RESTRICT_DEF: "RESTRICT f R x = (%y. if R y x then f y else ARB)"
+  sorry
+
+lemma RESTRICT_LEMMA: "xa xb xc ==> RESTRICT x xa xc xb = x xb"
+  sorry
+
+consts
+  approx :: "('a => 'a => bool) => (('a => 'b) => 'a => 'b) => 'a => ('a => 'b) => bool" 
+
+defs
+  approx_primdef: "approx == %R M x f. f = RESTRICT (%y. M (RESTRICT f R y) y) R x"
+
+lemma approx_def: "approx R M x f = (f = RESTRICT (%y. M (RESTRICT f R y) y) R x)"
+  sorry
+
+consts
+  the_fun :: "('a => 'a => bool) => (('a => 'b) => 'a => 'b) => 'a => 'a => 'b" 
+
+defs
+  the_fun_primdef: "the_fun == %R M x. Eps (approx R M x)"
+
+lemma the_fun_def: "the_fun R M x = Eps (approx R M x)"
+  sorry
+
+definition
+  WFREC :: "('a => 'a => bool) => (('a => 'b) => 'a => 'b) => 'a => 'b"  where
+  "WFREC ==
+%R M x. M (RESTRICT (the_fun (TC R) (%f v. M (RESTRICT f R v) v) x) R x) x"
+
+lemma WFREC_DEF: "WFREC R M =
+(%x. M (RESTRICT (the_fun (TC R) (%f v. M (RESTRICT f R v) v) x) R x) x)"
+  sorry
+
+lemma WFREC_THM: "WF R ==> WFREC R M x = M (RESTRICT (WFREC R M) R x) x"
+  sorry
+
+lemma WFREC_COROLLARY: "[| f = WFREC R M; WF R |] ==> f x = M (RESTRICT f R x) x"
+  sorry
+
+lemma WF_RECURSION_THM: "WF R ==> EX! f. ALL x. f x = M (RESTRICT f R x) x"
+  sorry
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" pair
+
+lemma CURRY_ONE_ONE_THM: "(curry f = curry g) = (f = g)"
+  sorry
+
+lemma UNCURRY_ONE_ONE_THM: "((%(x, y). f x y) = (%(x, y). g x y)) = (f = g)"
+  sorry
+
+lemma pair_Axiom: "EX x. ALL xa y. x (xa, y) = f xa y"
+  sorry
+
+lemma UNCURRY_CONG: "M = M' & (ALL x y. M' = (x, y) --> f x y = f' x y)
+==> prod_case f M = prod_case f' M'"
+  sorry
+
+lemma ELIM_PEXISTS: "(EX p. P (fst p) (snd p)) = (EX p1. Ex (P p1))"
+  sorry
+
+lemma ELIM_PFORALL: "(ALL p. P (fst p) (snd p)) = (ALL p1. All (P p1))"
+  sorry
+
+lemma PFORALL_THM: "(ALL xa. All (x xa)) = All (%(xa, y). x xa y)"
+  sorry
+
+lemma PEXISTS_THM: "(EX xa. Ex (x xa)) = Ex (%(xa, y). x xa y)"
+  sorry
+
+lemma LET2_RAND: "(x::'c => 'd)
+ (let (x::'a, y::'b) = xa::'a * 'b in (xb::'a => 'b => 'c) x y) =
+(let (xa::'a, y::'b) = xa in x (xb xa y))"
+  sorry
+
+lemma LET2_RATOR: "(let (x::'a1, y::'a2) = x::'a1 * 'a2 in (xa::'a1 => 'a2 => 'b => 'c) x y)
+ (xb::'b) =
+(let (x::'a1, y::'a2) = x in xa x y xb)"
+  sorry
+
+lemma pair_case_cong: "x = xa & (ALL x y. xa = (x, y) --> xb x y = f' x y)
+==> prod_case xb x = prod_case f' xa"
+  sorry
+
+definition
+  LEX :: "('a => 'a => bool) => ('b => 'b => bool) => 'a * 'b => 'a * 'b => bool"  where
+  "LEX == %R1 R2 (s, t) (u, v). R1 s u | s = u & R2 t v"
+
+lemma LEX_DEF: "LEX R1 R2 = (%(s, t) (u, v). R1 s u | s = u & R2 t v)"
+  sorry
+
+lemma WF_LEX: "WF x & WF xa ==> WF (LEX x xa)"
+  sorry
+
+definition
+  RPROD :: "('a => 'a => bool) => ('b => 'b => bool) => 'a * 'b => 'a * 'b => bool"  where
+  "RPROD == %R1 R2 (s, t) (u, v). R1 s u & R2 t v"
+
+lemma RPROD_DEF: "RPROD R1 R2 = (%(s, t) (u, v). R1 s u & R2 t v)"
+  sorry
+
+lemma WF_RPROD: "WF R & WF Q ==> WF (RPROD R Q)"
+  sorry
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" num
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" prim_rec
+
+lemma LESS_0_0: "0 < Suc 0"
+  sorry
+
+lemma LESS_LEMMA1: "x < Suc xa ==> x = xa | x < xa"
+  sorry
+
+lemma LESS_LEMMA2: "m = n | m < n ==> m < Suc n"
+  sorry
+
+lemma LESS_THM: "(m < Suc n) = (m = n | m < n)"
+  sorry
+
+lemma LESS_SUC_IMP: "[| x < Suc xa; x ~= xa |] ==> x < xa"
+  sorry
+
+lemma EQ_LESS: "Suc m = n ==> m < n"
+  sorry
+
+lemma NOT_LESS_EQ: "(m::nat) = (n::nat) ==> ~ m < n"
+  sorry
+
+definition
+  SIMP_REC_REL :: "(nat => 'a) => 'a => ('a => 'a) => nat => bool"  where
+  "SIMP_REC_REL == %fun x f n. fun 0 = x & (ALL m<n. fun (Suc m) = f (fun m))"
+
+lemma SIMP_REC_REL: "SIMP_REC_REL fun x f n = (fun 0 = x & (ALL m<n. fun (Suc m) = f (fun m)))"
+  sorry
+
+lemma SIMP_REC_EXISTS: "EX fun. SIMP_REC_REL fun x f n"
+  sorry
+
+lemma SIMP_REC_REL_UNIQUE: "[| SIMP_REC_REL xb x xa xd & SIMP_REC_REL xc x xa xe; n < xd & n < xe |]
+==> xb n = xc n"
+  sorry
+
+lemma SIMP_REC_REL_UNIQUE_RESULT: "EX! y. EX g. SIMP_REC_REL g x f (Suc n) & y = g n"
+  sorry
+
+consts
+  SIMP_REC :: "'a => ('a => 'a) => nat => 'a" 
+
+specification (SIMP_REC) SIMP_REC: "ALL x f' n. EX g. SIMP_REC_REL g x f' (Suc n) & SIMP_REC x f' n = g n"
+  sorry
+
+lemma LESS_SUC_SUC: "m < Suc m & m < Suc (Suc m)"
+  sorry
+
+lemma SIMP_REC_THM: "SIMP_REC x f 0 = x & (ALL m. SIMP_REC x f (Suc m) = f (SIMP_REC x f m))"
+  sorry
+
+definition
+  PRE :: "nat => nat"  where
+  "PRE == %m. if m = 0 then 0 else SOME n. m = Suc n"
+
+lemma PRE_DEF: "PRE m = (if m = 0 then 0 else SOME n. m = Suc n)"
+  sorry
+
+lemma PRE: "PRE 0 = 0 & (ALL m. PRE (Suc m) = m)"
+  sorry
+
+definition
+  PRIM_REC_FUN :: "'a => ('a => nat => 'a) => nat => nat => 'a"  where
+  "PRIM_REC_FUN == %x f. SIMP_REC (%n. x) (%fun n. f (fun (PRE n)) n)"
+
+lemma PRIM_REC_FUN: "PRIM_REC_FUN x f = SIMP_REC (%n. x) (%fun n. f (fun (PRE n)) n)"
+  sorry
+
+lemma PRIM_REC_EQN: "(ALL n. PRIM_REC_FUN x f 0 n = x) &
+(ALL m n. PRIM_REC_FUN x f (Suc m) n = f (PRIM_REC_FUN x f m (PRE n)) n)"
+  sorry
+
+definition
+  PRIM_REC :: "'a => ('a => nat => 'a) => nat => 'a"  where
+  "PRIM_REC == %x f m. PRIM_REC_FUN x f m (PRE m)"
+
+lemma PRIM_REC: "PRIM_REC x f m = PRIM_REC_FUN x f m (PRE m)"
+  sorry
+
+lemma PRIM_REC_THM: "PRIM_REC x f 0 = x & (ALL m. PRIM_REC x f (Suc m) = f (PRIM_REC x f m) m)"
+  sorry
+
+lemma DC: "P a & (ALL x. P x --> (EX y. P y & R x y))
+==> EX x. x 0 = a & (ALL n. P (x n) & R (x n) (x (Suc n)))"
+  sorry
+
+lemma num_Axiom_old: "EX! fn1. fn1 0 = e & (ALL n. fn1 (Suc n) = f (fn1 n) n)"
+  sorry
+
+lemma num_Axiom: "EX x. x 0 = e & (ALL n. x (Suc n) = f n (x n))"
+  sorry
+
+consts
+  wellfounded :: "('a => 'a => bool) => bool" 
+
+defs
+  wellfounded_primdef: "wellfounded == %R. ~ (EX f. ALL n. R (f (Suc n)) (f n))"
+
+lemma wellfounded_def: "wellfounded R = (~ (EX f. ALL n. R (f (Suc n)) (f n)))"
+  sorry
+
+lemma WF_IFF_WELLFOUNDED: "WF R = wellfounded R"
+  sorry
+
+lemma WF_PRED: "WF (%x y. y = Suc x)"
+  sorry
+
+lemma WF_LESS: "(WF::(nat => nat => bool) => bool) (op <::nat => nat => bool)"
+  sorry
+
+consts
+  measure :: "('a => nat) => 'a => 'a => bool" 
+
+defs
+  measure_primdef: "prim_rec.measure == relation.inv_image op <"
+
+lemma measure_def: "prim_rec.measure = relation.inv_image op <"
+  sorry
+
+lemma WF_measure: "WF (prim_rec.measure x)"
+  sorry
+
+lemma measure_thm: "prim_rec.measure x xa xb = (x xa < x xb)"
+  sorry
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" arithmetic
+
+definition
+  nat_elim__magic :: "nat => nat"  where
+  "nat_elim__magic == %n. n"
+
+lemma nat_elim__magic: "nat_elim__magic n = n"
+  sorry
+
+consts
+  EVEN :: "nat => bool" 
+
+specification (EVEN) EVEN: "EVEN 0 = True & (ALL n. EVEN (Suc n) = (~ EVEN n))"
+  sorry
+
+consts
+  ODD :: "nat => bool" 
+
+specification (ODD) ODD: "ODD 0 = False & (ALL n. ODD (Suc n) = (~ ODD n))"
+  sorry
+
+lemma TWO: "2 = Suc 1"
+  sorry
+
+lemma NORM_0: "(0::nat) = (0::nat)"
+  sorry
+
+lemma num_case_compute: "nat_case f g n = (if n = 0 then f else g (PRE n))"
+  sorry
+
+lemma ADD_CLAUSES: "0 + m = m & m + 0 = m & Suc m + n = Suc (m + n) & m + Suc n = Suc (m + n)"
+  sorry
+
+lemma LESS_ADD: "(n::nat) < (m::nat) ==> EX p::nat. p + n = m"
+  sorry
+
+lemma LESS_ANTISYM: "~ ((m::nat) < (n::nat) & n < m)"
+  sorry
+
+lemma LESS_LESS_SUC: "~ (x < xa & xa < Suc x)"
+  sorry
+
+lemma FUN_EQ_LEMMA: "f x1 & ~ f x2 ==> x1 ~= x2"
+  sorry
+
+lemma LESS_NOT_SUC: "m < n & n ~= Suc m ==> Suc m < n"
+  sorry
+
+lemma LESS_0_CASES: "(0::nat) = (m::nat) | (0::nat) < m"
+  sorry
+
+lemma LESS_CASES_IMP: "~ (m::nat) < (n::nat) & m ~= n ==> n < m"
+  sorry
+
+lemma LESS_CASES: "(m::nat) < (n::nat) | n <= m"
+  sorry
+
+lemma LESS_EQ_SUC_REFL: "m <= Suc m"
+  sorry
+
+lemma LESS_ADD_NONZERO: "(n::nat) ~= (0::nat) ==> (m::nat) < m + n"
+  sorry
+
+lemma LESS_EQ_ANTISYM: "~ ((x::nat) < (xa::nat) & xa <= x)"
+  sorry
+
+lemma SUB_0: "(0::nat) - (m::nat) = (0::nat) & m - (0::nat) = m"
+  sorry
+
+lemma PRE_SUB1: "PRE m = m - 1"
+  sorry
+
+lemma MULT_CLAUSES: "0 * x = 0 &
+x * 0 = 0 &
+1 * x = x & x * 1 = x & Suc x * xa = x * xa + xa & x * Suc xa = x + x * xa"
+  sorry
+
+lemma PRE_SUB: "PRE (m - n) = PRE m - n"
+  sorry
+
+lemma ADD_EQ_1: "((m::nat) + (n::nat) = (1::nat)) =
+(m = (1::nat) & n = (0::nat) | m = (0::nat) & n = (1::nat))"
+  sorry
+
+lemma ADD_INV_0_EQ: "((m::nat) + (n::nat) = m) = (n = (0::nat))"
+  sorry
+
+lemma PRE_SUC_EQ: "0 < n ==> (m = PRE n) = (Suc m = n)"
+  sorry
+
+lemma INV_PRE_EQ: "0 < m & 0 < n ==> (PRE m = PRE n) = (m = n)"
+  sorry
+
+lemma LESS_SUC_NOT: "m < n ==> ~ n < Suc m"
+  sorry
+
+lemma ADD_EQ_SUB: "(n::nat) <= (p::nat) ==> ((m::nat) + n = p) = (m = p - n)"
+  sorry
+
+lemma LESS_ADD_1: "(xa::nat) < (x::nat) ==> EX xb::nat. x = xa + (xb + (1::nat))"
+  sorry
+
+lemma NOT_ODD_EQ_EVEN: "Suc (n + n) ~= m + m"
+  sorry
+
+lemma MULT_SUC_EQ: "(n * Suc p = m * Suc p) = (n = m)"
+  sorry
+
+lemma MULT_EXP_MONO: "(n * Suc q ^ p = m * Suc q ^ p) = (n = m)"
+  sorry
+
+lemma LESS_ADD_SUC: "m < m + Suc n"
+  sorry
+
+lemma LESS_OR_EQ_ADD: "(n::nat) < (m::nat) | (EX p::nat. n = p + m)"
+  sorry
+
+lemma WOP: "Ex (P::nat => bool) ==> EX n::nat. P n & (ALL m<n. ~ P m)"
+  sorry
+
+lemma INV_PRE_LESS: "0 < m ==> (PRE m < PRE n) = (m < n)"
+  sorry
+
+lemma INV_PRE_LESS_EQ: "0 < n ==> (PRE m <= PRE n) = (m <= n)"
+  sorry
+
+lemma SUB_EQ_EQ_0: "((m::nat) - (n::nat) = m) = (m = (0::nat) | n = (0::nat))"
+  sorry
+
+lemma SUB_LESS_OR: "(n::nat) < (m::nat) ==> n <= m - (1::nat)"
+  sorry
+
+lemma LESS_SUB_ADD_LESS: "(i::nat) < (n::nat) - (m::nat) ==> i + m < n"
+  sorry
+
+lemma LESS_EQ_SUB_LESS: "(xa::nat) <= (x::nat) ==> (x - xa < (c::nat)) = (x < xa + c)"
+  sorry
+
+lemma NOT_SUC_LESS_EQ: "(~ Suc x <= xa) = (xa <= x)"
+  sorry
+
+lemma SUB_LESS_EQ_ADD: "(m::nat) <= (p::nat) ==> (p - m <= (n::nat)) = (p <= m + n)"
+  sorry
+
+lemma SUB_CANCEL: "(xa::nat) <= (x::nat) & (xb::nat) <= x ==> (x - xa = x - xb) = (xa = xb)"
+  sorry
+
+lemma NOT_EXP_0: "Suc n ^ m ~= 0"
+  sorry
+
+lemma ZERO_LESS_EXP: "0 < Suc n ^ m"
+  sorry
+
+lemma ODD_OR_EVEN: "EX xa. x = Suc (Suc 0) * xa | x = Suc (Suc 0) * xa + 1"
+  sorry
+
+lemma LESS_EXP_SUC_MONO: "Suc (Suc m) ^ n < Suc (Suc m) ^ Suc n"
+  sorry
+
+lemma LESS_LESS_CASES: "(m::nat) = (n::nat) | m < n | n < m"
+  sorry
+
+consts
+  FACT :: "nat => nat" 
+
+specification (FACT) FACT: "FACT 0 = 1 & (ALL n. FACT (Suc n) = Suc n * FACT n)"
+  sorry
+
+lemma FACT_LESS: "0 < FACT n"
+  sorry
+
+lemma EVEN_ODD: "EVEN n = (~ ODD n)"
+  sorry
+
+lemma ODD_EVEN: "ODD x = (~ EVEN x)"
+  sorry
+
+lemma EVEN_OR_ODD: "EVEN x | ODD x"
+  sorry
+
+lemma EVEN_AND_ODD: "~ (EVEN x & ODD x)"
+  sorry
+
+lemma EVEN_ADD: "EVEN (m + n) = (EVEN m = EVEN n)"
+  sorry
+
+lemma EVEN_MULT: "EVEN (m * n) = (EVEN m | EVEN n)"
+  sorry
+
+lemma ODD_ADD: "ODD (m + n) = (ODD m ~= ODD n)"
+  sorry
+
+lemma ODD_MULT: "ODD (m * n) = (ODD m & ODD n)"
+  sorry
+
+lemma EVEN_DOUBLE: "EVEN (2 * n)"
+  sorry
+
+lemma ODD_DOUBLE: "ODD (Suc (2 * x))"
+  sorry
+
+lemma EVEN_ODD_EXISTS: "(EVEN x --> (EX m. x = 2 * m)) & (ODD x --> (EX m. x = Suc (2 * m)))"
+  sorry
+
+lemma EVEN_EXISTS: "EVEN n = (EX m. n = 2 * m)"
+  sorry
+
+lemma ODD_EXISTS: "ODD n = (EX m. n = Suc (2 * m))"
+  sorry
+
+lemma NOT_SUC_LESS_EQ_0: "~ Suc x <= 0"
+  sorry
+
+lemma NOT_NUM_EQ: "(x ~= xa) = (Suc x <= xa | Suc xa <= x)"
+  sorry
+
+lemma SUC_ADD_SYM: "Suc (m + n) = Suc n + m"
+  sorry
+
+lemma NOT_SUC_ADD_LESS_EQ: "~ Suc (m + n) <= m"
+  sorry
+
+lemma SUB_LEFT_ADD: "(m::nat) + ((n::nat) - (p::nat)) = (if n <= p then m else m + n - p)"
+  sorry
+
+lemma SUB_RIGHT_ADD: "(m::nat) - (n::nat) + (p::nat) = (if m <= n then p else m + p - n)"
+  sorry
+
+lemma SUB_LEFT_SUB: "(m::nat) - ((n::nat) - (p::nat)) = (if n <= p then m else m + p - n)"
+  sorry
+
+lemma SUB_LEFT_SUC: "Suc (m - n) = (if m <= n then Suc 0 else Suc m - n)"
+  sorry
+
+lemma SUB_LEFT_LESS_EQ: "((m::nat) <= (n::nat) - (p::nat)) = (m + p <= n | m <= (0::nat))"
+  sorry
+
+lemma SUB_RIGHT_LESS_EQ: "((m::nat) - (n::nat) <= (p::nat)) = (m <= n + p)"
+  sorry
+
+lemma SUB_RIGHT_LESS: "((m::nat) - (n::nat) < (p::nat)) = (m < n + p & (0::nat) < p)"
+  sorry
+
+lemma SUB_RIGHT_GREATER_EQ: "((p::nat) <= (m::nat) - (n::nat)) = (n + p <= m | p <= (0::nat))"
+  sorry
+
+lemma SUB_LEFT_GREATER: "((n::nat) - (p::nat) < (m::nat)) = (n < m + p & (0::nat) < m)"
+  sorry
+
+lemma SUB_RIGHT_GREATER: "((p::nat) < (m::nat) - (n::nat)) = (n + p < m)"
+  sorry
+
+lemma SUB_LEFT_EQ: "((m::nat) = (n::nat) - (p::nat)) = (m + p = n | m <= (0::nat) & n <= p)"
+  sorry
+
+lemma SUB_RIGHT_EQ: "((m::nat) - (n::nat) = (p::nat)) = (m = n + p | m <= n & p <= (0::nat))"
+  sorry
+
+lemma LE: "(ALL n::nat. (n <= (0::nat)) = (n = (0::nat))) &
+(ALL (m::nat) n::nat. (m <= Suc n) = (m = Suc n | m <= n))"
+  sorry
+
+lemma DA: "(0::nat) < (n::nat) ==> EX (x::nat) q::nat. (k::nat) = q * n + x & x < n"
+  sorry
+
+lemma DIV_LESS_EQ: "(0::nat) < (n::nat) ==> (k::nat) div n <= k"
+  sorry
+
+lemma DIV_UNIQUE: "EX r::nat. (k::nat) = (q::nat) * (n::nat) + r & r < n ==> k div n = q"
+  sorry
+
+lemma MOD_UNIQUE: "EX q::nat. (k::nat) = q * (n::nat) + (r::nat) & r < n ==> k mod n = r"
+  sorry
+
+lemma DIV_MULT: "(r::nat) < (n::nat) ==> ((q::nat) * n + r) div n = q"
+  sorry
+
+lemma MOD_EQ_0: "(0::nat) < (n::nat) ==> (k::nat) * n mod n = (0::nat)"
+  sorry
+
+lemma ZERO_MOD: "(0::nat) < (n::nat) ==> (0::nat) mod n = (0::nat)"
+  sorry
+
+lemma ZERO_DIV: "(0::nat) < (n::nat) ==> (0::nat) div n = (0::nat)"
+  sorry
+
+lemma MOD_MULT: "(r::nat) < (n::nat) ==> ((q::nat) * n + r) mod n = r"
+  sorry
+
+lemma MOD_TIMES: "(0::nat) < (n::nat) ==> ((q::nat) * n + (r::nat)) mod n = r mod n"
+  sorry
+
+lemma MOD_PLUS: "(0::nat) < (n::nat)
+==> ((j::nat) mod n + (k::nat) mod n) mod n = (j + k) mod n"
+  sorry
+
+lemma MOD_MOD: "(0::nat) < (n::nat) ==> (k::nat) mod n mod n = k mod n"
+  sorry
+
+lemma ADD_DIV_ADD_DIV: "(0::nat) < (x::nat) ==> ((xa::nat) * x + (r::nat)) div x = xa + r div x"
+  sorry
+
+lemma MOD_MULT_MOD: "(0::nat) < (n::nat) & (0::nat) < (m::nat)
+==> (x::nat) mod (n * m) mod n = x mod n"
+  sorry
+
+lemma DIVMOD_ID: "(0::nat) < (n::nat) ==> n div n = (1::nat) & n mod n = (0::nat)"
+  sorry
+
+lemma DIV_DIV_DIV_MULT: "(0::nat) < (x::nat) & (0::nat) < (xa::nat)
+==> (xb::nat) div x div xa = xb div (x * xa)"
+  sorry
+
+lemma DIV_P: "(0::nat) < (q::nat)
+==> (P::nat => bool) ((p::nat) div q) =
+    (EX (k::nat) r::nat. p = k * q + r & r < q & P k)"
+  sorry
+
+lemma MOD_P: "(0::nat) < (q::nat)
+==> (P::nat => bool) ((p::nat) mod q) =
+    (EX (k::nat) r::nat. p = k * q + r & r < q & P r)"
+  sorry
+
+lemma MOD_TIMES2: "(0::nat) < (n::nat)
+==> (j::nat) mod n * ((k::nat) mod n) mod n = j * k mod n"
+  sorry
+
+lemma MOD_COMMON_FACTOR: "(0::nat) < (n::nat) & (0::nat) < (q::nat)
+==> n * ((p::nat) mod q) = n * p mod (n * q)"
+  sorry
+
+lemma num_case_cong: "M = M' & (M' = 0 --> b = b') & (ALL n. M' = Suc n --> f n = f' n)
+==> nat_case b f M = nat_case b' f' M'"
+  sorry
+
+lemma SUC_ELIM_THM: "(ALL n. P (Suc n) n) = (ALL n>0. P n (n - 1))"
+  sorry
+
+lemma SUB_ELIM_THM: "(P::nat => bool) ((a::nat) - (b::nat)) =
+(ALL x::nat. (b = a + x --> P (0::nat)) & (a = b + x --> P x))"
+  sorry
+
+lemma PRE_ELIM_THM: "P (PRE n) = (ALL m. (n = 0 --> P 0) & (n = Suc m --> P m))"
+  sorry
+
+lemma MULT_INCREASES: "1 < m & 0 < n ==> Suc n <= m * n"
+  sorry
+
+lemma EXP_ALWAYS_BIG_ENOUGH: "(1::nat) < (b::nat) ==> EX m::nat. (n::nat) <= b ^ m"
+  sorry
+
+lemma EXP_EQ_0: "((n::nat) ^ (m::nat) = (0::nat)) = (n = (0::nat) & (0::nat) < m)"
+  sorry
+
+lemma EXP_1: "(1::nat) ^ (x::nat) = (1::nat) & x ^ (1::nat) = x"
+  sorry
+
+lemma MIN_MAX_EQ: "(min (x::nat) (xa::nat) = max x xa) = (x = xa)"
+  sorry
+
+lemma MIN_MAX_LT: "(min (x::nat) (xa::nat) < max x xa) = (x ~= xa)"
+  sorry
+
+lemma MIN_MAX_PRED: "(P::nat => bool) (m::nat) & P (n::nat) ==> P (min m n) & P (max m n)"
+  sorry
+
+lemma MIN_LT: "(min (xa::nat) (x::nat) < xa) = (xa ~= x & min xa x = x) &
+(min xa x < x) = (xa ~= x & min xa x = xa) &
+(xa < min xa x) = False & (x < min xa x) = False"
+  sorry
+
+lemma MAX_LT: "((xa::nat) < max xa (x::nat)) = (xa ~= x & max xa x = x) &
+(x < max xa x) = (xa ~= x & max xa x = xa) &
+(max xa x < xa) = False & (max xa x < x) = False"
+  sorry
+
+lemma MIN_LE: "min (xa::nat) (x::nat) <= xa & min xa x <= x"
+  sorry
+
+lemma MAX_LE: "(xa::nat) <= max xa (x::nat) & x <= max xa x"
+  sorry
+
+lemma MIN_0: "min (x::nat) (0::nat) = (0::nat) & min (0::nat) x = (0::nat)"
+  sorry
+
+lemma MAX_0: "max (x::nat) (0::nat) = x & max (0::nat) x = x"
+  sorry
+
+lemma EXISTS_GREATEST: "(Ex (P::nat => bool) & (EX x::nat. ALL y>x. ~ P y)) =
+(EX x::nat. P x & (ALL y>x. ~ P y))"
+  sorry
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" hrat
+
+definition
+  trat_1 :: "nat * nat"  where
+  "trat_1 == (0, 0)"
+
+lemma trat_1: "trat_1 = (0, 0)"
+  sorry
+
+definition
+  trat_inv :: "nat * nat => nat * nat"  where
+  "trat_inv == %(x, y). (y, x)"
+
+lemma trat_inv: "trat_inv (x, y) = (y, x)"
+  sorry
+
+definition
+  trat_add :: "nat * nat => nat * nat => nat * nat"  where
+  "trat_add ==
+%(x, y) (x', y').
+   (PRE (Suc x * Suc y' + Suc x' * Suc y), PRE (Suc y * Suc y'))"
+
+lemma trat_add: "trat_add (x, y) (x', y') =
+(PRE (Suc x * Suc y' + Suc x' * Suc y), PRE (Suc y * Suc y'))"
+  sorry
+
+definition
+  trat_mul :: "nat * nat => nat * nat => nat * nat"  where
+  "trat_mul == %(x, y) (x', y'). (PRE (Suc x * Suc x'), PRE (Suc y * Suc y'))"
+
+lemma trat_mul: "trat_mul (x, y) (x', y') = (PRE (Suc x * Suc x'), PRE (Suc y * Suc y'))"
+  sorry
+
+consts
+  trat_sucint :: "nat => nat * nat" 
+
+specification (trat_sucint) trat_sucint: "trat_sucint 0 = trat_1 &
+(ALL n. trat_sucint (Suc n) = trat_add (trat_sucint n) trat_1)"
+  sorry
+
+definition
+  trat_eq :: "nat * nat => nat * nat => bool"  where
+  "trat_eq == %(x, y) (x', y'). Suc x * Suc y' = Suc x' * Suc y"
+
+lemma trat_eq: "trat_eq (x, y) (x', y') = (Suc x * Suc y' = Suc x' * Suc y)"
+  sorry
+
+lemma TRAT_EQ_REFL: "trat_eq p p"
+  sorry
+
+lemma TRAT_EQ_SYM: "trat_eq p q = trat_eq q p"
+  sorry
+
+lemma TRAT_EQ_TRANS: "trat_eq p q & trat_eq q r ==> trat_eq p r"
+  sorry
+
+lemma TRAT_EQ_AP: "p = q ==> trat_eq p q"
+  sorry
+
+lemma TRAT_ADD_SYM_EQ: "trat_add h i = trat_add i h"
+  sorry
+
+lemma TRAT_MUL_SYM_EQ: "trat_mul h i = trat_mul i h"
+  sorry
+
+lemma TRAT_INV_WELLDEFINED: "trat_eq p q ==> trat_eq (trat_inv p) (trat_inv q)"
+  sorry
+
+lemma TRAT_ADD_WELLDEFINED: "trat_eq p q ==> trat_eq (trat_add p r) (trat_add q r)"
+  sorry
+
+lemma TRAT_ADD_WELLDEFINED2: "trat_eq p1 p2 & trat_eq q1 q2 ==> trat_eq (trat_add p1 q1) (trat_add p2 q2)"
+  sorry
+
+lemma TRAT_MUL_WELLDEFINED: "trat_eq p q ==> trat_eq (trat_mul p r) (trat_mul q r)"
+  sorry
+
+lemma TRAT_MUL_WELLDEFINED2: "trat_eq p1 p2 & trat_eq q1 q2 ==> trat_eq (trat_mul p1 q1) (trat_mul p2 q2)"
+  sorry
+
+lemma TRAT_ADD_SYM: "trat_eq (trat_add h i) (trat_add i h)"
+  sorry
+
+lemma TRAT_ADD_ASSOC: "trat_eq (trat_add h (trat_add i j)) (trat_add (trat_add h i) j)"
+  sorry
+
+lemma TRAT_MUL_SYM: "trat_eq (trat_mul h i) (trat_mul i h)"
+  sorry
+
+lemma TRAT_MUL_ASSOC: "trat_eq (trat_mul h (trat_mul i j)) (trat_mul (trat_mul h i) j)"
+  sorry
+
+lemma TRAT_LDISTRIB: "trat_eq (trat_mul h (trat_add i j)) (trat_add (trat_mul h i) (trat_mul h j))"
+  sorry
+
+lemma TRAT_MUL_LID: "trat_eq (trat_mul trat_1 h) h"
+  sorry
+
+lemma TRAT_MUL_LINV: "trat_eq (trat_mul (trat_inv h) h) trat_1"
+  sorry
+
+lemma TRAT_NOZERO: "~ trat_eq (trat_add h i) h"
+  sorry
+
+lemma TRAT_ADD_TOTAL: "trat_eq h i |
+(EX d. trat_eq h (trat_add i d)) | (EX d. trat_eq i (trat_add h d))"
+  sorry
+
+lemma TRAT_SUCINT_0: "trat_eq (trat_sucint n) (n, 0)"
+  sorry
+
+lemma TRAT_ARCH: "EX n d. trat_eq (trat_sucint n) (trat_add h d)"
+  sorry
+
+lemma TRAT_SUCINT: "trat_eq (trat_sucint 0) trat_1 &
+(ALL n. trat_eq (trat_sucint (Suc n)) (trat_add (trat_sucint n) trat_1))"
+  sorry
+
+lemma TRAT_EQ_EQUIV: "trat_eq p q = (trat_eq p = trat_eq q)"
+  sorry
+
+typedef (open) hrat = "{x. EX xa. x = trat_eq xa}" 
+  sorry
+
+lemmas hrat_TY_DEF = typedef_hol2hol4 [OF type_definition_hrat]
+
+consts
+  mk_hrat :: "(nat * nat => bool) => hrat" 
+  dest_hrat :: "hrat => nat * nat => bool" 
+
+specification (dest_hrat mk_hrat) hrat_tybij: "(ALL a. mk_hrat (dest_hrat a) = a) &
+(ALL r. (EX x. r = trat_eq x) = (dest_hrat (mk_hrat r) = r))"
+  sorry
+
+definition
+  hrat_1 :: "hrat"  where
+  "hrat_1 == mk_hrat (trat_eq trat_1)"
+
+lemma hrat_1: "hrat_1 = mk_hrat (trat_eq trat_1)"
+  sorry
+
+definition
+  hrat_inv :: "hrat => hrat"  where
+  "hrat_inv == %T1. mk_hrat (trat_eq (trat_inv (Eps (dest_hrat T1))))"
+
+lemma hrat_inv: "hrat_inv T1 = mk_hrat (trat_eq (trat_inv (Eps (dest_hrat T1))))"
+  sorry
+
+definition
+  hrat_add :: "hrat => hrat => hrat"  where
+  "hrat_add ==
+%T1 T2.
+   mk_hrat (trat_eq (trat_add (Eps (dest_hrat T1)) (Eps (dest_hrat T2))))"
+
+lemma hrat_add: "hrat_add T1 T2 =
+mk_hrat (trat_eq (trat_add (Eps (dest_hrat T1)) (Eps (dest_hrat T2))))"
+  sorry
+
+definition
+  hrat_mul :: "hrat => hrat => hrat"  where
+  "hrat_mul ==
+%T1 T2.
+   mk_hrat (trat_eq (trat_mul (Eps (dest_hrat T1)) (Eps (dest_hrat T2))))"
+
+lemma hrat_mul: "hrat_mul T1 T2 =
+mk_hrat (trat_eq (trat_mul (Eps (dest_hrat T1)) (Eps (dest_hrat T2))))"
+  sorry
+
+definition
+  hrat_sucint :: "nat => hrat"  where
+  "hrat_sucint == %T1. mk_hrat (trat_eq (trat_sucint T1))"
+
+lemma hrat_sucint: "hrat_sucint T1 = mk_hrat (trat_eq (trat_sucint T1))"
+  sorry
+
+lemma HRAT_ADD_SYM: "hrat_add h i = hrat_add i h"
+  sorry
+
+lemma HRAT_ADD_ASSOC: "hrat_add h (hrat_add i j) = hrat_add (hrat_add h i) j"
+  sorry
+
+lemma HRAT_MUL_SYM: "hrat_mul h i = hrat_mul i h"
+  sorry
+
+lemma HRAT_MUL_ASSOC: "hrat_mul h (hrat_mul i j) = hrat_mul (hrat_mul h i) j"
+  sorry
+
+lemma HRAT_LDISTRIB: "hrat_mul h (hrat_add i j) = hrat_add (hrat_mul h i) (hrat_mul h j)"
+  sorry
+
+lemma HRAT_MUL_LID: "hrat_mul hrat_1 h = h"
+  sorry
+
+lemma HRAT_MUL_LINV: "hrat_mul (hrat_inv h) h = hrat_1"
+  sorry
+
+lemma HRAT_NOZERO: "hrat_add h i ~= h"
+  sorry
+
+lemma HRAT_ADD_TOTAL: "h = i | (EX x. h = hrat_add i x) | (EX x. i = hrat_add h x)"
+  sorry
+
+lemma HRAT_ARCH: "EX x xa. hrat_sucint x = hrat_add h xa"
+  sorry
+
+lemma HRAT_SUCINT: "hrat_sucint 0 = hrat_1 &
+(ALL x. hrat_sucint (Suc x) = hrat_add (hrat_sucint x) hrat_1)"
+  sorry
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" hreal
+
+definition
+  hrat_lt :: "hrat => hrat => bool"  where
+  "hrat_lt == %x y. EX d. y = hrat_add x d"
+
+lemma hrat_lt: "hrat_lt x y = (EX d. y = hrat_add x d)"
+  sorry
+
+lemma HRAT_LT_REFL: "~ hrat_lt x x"
+  sorry
+
+lemma HRAT_LT_TRANS: "hrat_lt x y & hrat_lt y z ==> hrat_lt x z"
+  sorry
+
+lemma HRAT_LT_ANTISYM: "~ (hrat_lt x y & hrat_lt y x)"
+  sorry
+
+lemma HRAT_LT_TOTAL: "x = y | hrat_lt x y | hrat_lt y x"
+  sorry
+
+lemma HRAT_MUL_RID: "hrat_mul x hrat_1 = x"
+  sorry
+
+lemma HRAT_MUL_RINV: "hrat_mul x (hrat_inv x) = hrat_1"
+  sorry
+
+lemma HRAT_RDISTRIB: "hrat_mul (hrat_add x y) z = hrat_add (hrat_mul x z) (hrat_mul y z)"
+  sorry
+
+lemma HRAT_LT_ADDL: "hrat_lt x (hrat_add x y)"
+  sorry
+
+lemma HRAT_LT_ADDR: "hrat_lt xa (hrat_add x xa)"
+  sorry
+
+lemma HRAT_LT_GT: "hrat_lt x y ==> ~ hrat_lt y x"
+  sorry
+
+lemma HRAT_LT_NE: "hrat_lt x y ==> x ~= y"
+  sorry
+
+lemma HRAT_EQ_LADD: "(hrat_add x y = hrat_add x z) = (y = z)"
+  sorry
+
+lemma HRAT_EQ_LMUL: "(hrat_mul x y = hrat_mul x z) = (y = z)"
+  sorry
+
+lemma HRAT_LT_ADD2: "hrat_lt u x & hrat_lt v y ==> hrat_lt (hrat_add u v) (hrat_add x y)"
+  sorry
+
+lemma HRAT_LT_LADD: "hrat_lt (hrat_add z x) (hrat_add z y) = hrat_lt x y"
+  sorry
+
+lemma HRAT_LT_RADD: "hrat_lt (hrat_add x z) (hrat_add y z) = hrat_lt x y"
+  sorry
+
+lemma HRAT_LT_MUL2: "hrat_lt u x & hrat_lt v y ==> hrat_lt (hrat_mul u v) (hrat_mul x y)"
+  sorry
+
+lemma HRAT_LT_LMUL: "hrat_lt (hrat_mul z x) (hrat_mul z y) = hrat_lt x y"
+  sorry
+
+lemma HRAT_LT_RMUL: "hrat_lt (hrat_mul x z) (hrat_mul y z) = hrat_lt x y"
+  sorry
+
+lemma HRAT_LT_LMUL1: "hrat_lt (hrat_mul x y) y = hrat_lt x hrat_1"
+  sorry
+
+lemma HRAT_LT_RMUL1: "hrat_lt (hrat_mul x y) x = hrat_lt y hrat_1"
+  sorry
+
+lemma HRAT_GT_LMUL1: "hrat_lt y (hrat_mul x y) = hrat_lt hrat_1 x"
+  sorry
+
+lemma HRAT_LT_L1: "hrat_lt (hrat_mul (hrat_inv x) y) hrat_1 = hrat_lt y x"
+  sorry
+
+lemma HRAT_LT_R1: "hrat_lt (hrat_mul x (hrat_inv y)) hrat_1 = hrat_lt x y"
+  sorry
+
+lemma HRAT_GT_L1: "hrat_lt hrat_1 (hrat_mul (hrat_inv x) y) = hrat_lt x y"
+  sorry
+
+lemma HRAT_INV_MUL: "hrat_inv (hrat_mul x y) = hrat_mul (hrat_inv x) (hrat_inv y)"
+  sorry
+
+lemma HRAT_UP: "Ex (hrat_lt x)"
+  sorry
+
+lemma HRAT_DOWN: "EX xa. hrat_lt xa x"
+  sorry
+
+lemma HRAT_DOWN2: "EX xa. hrat_lt xa x & hrat_lt xa y"
+  sorry
+
+lemma HRAT_MEAN: "hrat_lt x y ==> EX xa. hrat_lt x xa & hrat_lt xa y"
+  sorry
+
+definition
+  isacut :: "(hrat => bool) => bool"  where
+  "isacut ==
+%C. Ex C &
+    (EX x. ~ C x) &
+    (ALL x y. C x & hrat_lt y x --> C y) &
+    (ALL x. C x --> (EX y. C y & hrat_lt x y))"
+
+lemma isacut: "isacut (CC::hrat => bool) =
+(Ex CC &
+ (EX x::hrat. ~ CC x) &
+ (ALL (x::hrat) y::hrat. CC x & hrat_lt y x --> CC y) &
+ (ALL x::hrat. CC x --> (EX y::hrat. CC y & hrat_lt x y)))"
+  sorry
+
+definition
+  cut_of_hrat :: "hrat => hrat => bool"  where
+  "cut_of_hrat == %x y. hrat_lt y x"
+
+lemma cut_of_hrat: "cut_of_hrat x = (%y. hrat_lt y x)"
+  sorry
+
+lemma ISACUT_HRAT: "isacut (cut_of_hrat h)"
+  sorry
+
+typedef (open) hreal = "Collect isacut" 
+  sorry
+
+lemmas hreal_TY_DEF = typedef_hol2hol4 [OF type_definition_hreal]
+
+consts
+  hreal :: "(hrat => bool) => hreal" 
+  cut :: "hreal => hrat => bool" 
+
+specification (cut hreal) hreal_tybij: "(ALL a. hreal (cut a) = a) & (ALL r. isacut r = (cut (hreal r) = r))"
+  sorry
+
+lemma EQUAL_CUTS: "cut X = cut Y ==> X = Y"
+  sorry
+
+lemma CUT_ISACUT: "isacut (cut x)"
+  sorry
+
+lemma CUT_NONEMPTY: "Ex (cut x)"
+  sorry
+
+lemma CUT_BOUNDED: "EX xa. ~ cut x xa"
+  sorry
+
+lemma CUT_DOWN: "cut x xa & hrat_lt xb xa ==> cut x xb"
+  sorry
+
+lemma CUT_UP: "cut x xa ==> EX y. cut x y & hrat_lt xa y"
+  sorry
+
+lemma CUT_UBOUND: "~ cut x xa & hrat_lt xa xb ==> ~ cut x xb"
+  sorry
+
+lemma CUT_STRADDLE: "cut X x & ~ cut X y ==> hrat_lt x y"
+  sorry
+
+lemma CUT_NEARTOP_ADD: "EX x. cut X x & ~ cut X (hrat_add x e)"
+  sorry
+
+lemma CUT_NEARTOP_MUL: "hrat_lt hrat_1 u ==> EX x. cut X x & ~ cut X (hrat_mul u x)"
+  sorry
+
+definition
+  hreal_1 :: "hreal"  where
+  "hreal_1 == hreal (cut_of_hrat hrat_1)"
+
+lemma hreal_1: "hreal_1 = hreal (cut_of_hrat hrat_1)"
+  sorry
+
+definition
+  hreal_add :: "hreal => hreal => hreal"  where
+  "hreal_add == %X Y. hreal (%w. EX x y. w = hrat_add x y & cut X x & cut Y y)"
+
+lemma hreal_add: "hreal_add X Y = hreal (%w. EX x y. w = hrat_add x y & cut X x & cut Y y)"
+  sorry
+
+definition
+  hreal_mul :: "hreal => hreal => hreal"  where
+  "hreal_mul == %X Y. hreal (%w. EX x y. w = hrat_mul x y & cut X x & cut Y y)"
+
+lemma hreal_mul: "hreal_mul X Y = hreal (%w. EX x y. w = hrat_mul x y & cut X x & cut Y y)"
+  sorry
+
+definition
+  hreal_inv :: "hreal => hreal"  where
+  "hreal_inv ==
+%X. hreal
+     (%w. EX d. hrat_lt d hrat_1 &
+                (ALL x. cut X x --> hrat_lt (hrat_mul w x) d))"
+
+lemma hreal_inv: "hreal_inv X =
+hreal
+ (%w. EX d. hrat_lt d hrat_1 &
+            (ALL x. cut X x --> hrat_lt (hrat_mul w x) d))"
+  sorry
+
+definition
+  hreal_sup :: "(hreal => bool) => hreal"  where
+  "hreal_sup == %P. hreal (%w. EX X. P X & cut X w)"
+
+lemma hreal_sup: "hreal_sup P = hreal (%w. EX X. P X & cut X w)"
+  sorry
+
+definition
+  hreal_lt :: "hreal => hreal => bool"  where
+  "hreal_lt == %X Y. X ~= Y & (ALL x. cut X x --> cut Y x)"
+
+lemma hreal_lt: "hreal_lt X Y = (X ~= Y & (ALL x. cut X x --> cut Y x))"
+  sorry
+
+lemma HREAL_INV_ISACUT: "isacut
+ (%w. EX d. hrat_lt d hrat_1 &
+            (ALL x. cut X x --> hrat_lt (hrat_mul w x) d))"
+  sorry
+
+lemma HREAL_ADD_ISACUT: "isacut (%w. EX x y. w = hrat_add x y & cut X x & cut Y y)"
+  sorry
+
+lemma HREAL_MUL_ISACUT: "isacut (%w. EX x y. w = hrat_mul x y & cut X x & cut Y y)"
+  sorry
+
+lemma HREAL_ADD_SYM: "hreal_add X Y = hreal_add Y X"
+  sorry
+
+lemma HREAL_MUL_SYM: "hreal_mul X Y = hreal_mul Y X"
+  sorry
+
+lemma HREAL_ADD_ASSOC: "hreal_add X (hreal_add Y Z) = hreal_add (hreal_add X Y) Z"
+  sorry
+
+lemma HREAL_MUL_ASSOC: "hreal_mul X (hreal_mul Y Z) = hreal_mul (hreal_mul X Y) Z"
+  sorry
+
+lemma HREAL_LDISTRIB: "hreal_mul X (hreal_add Y Z) = hreal_add (hreal_mul X Y) (hreal_mul X Z)"
+  sorry
+
+lemma HREAL_MUL_LID: "hreal_mul hreal_1 X = X"
+  sorry
+
+lemma HREAL_MUL_LINV: "hreal_mul (hreal_inv X) X = hreal_1"
+  sorry
+
+lemma HREAL_NOZERO: "hreal_add X Y ~= X"
+  sorry
+
+definition
+  hreal_sub :: "hreal => hreal => hreal"  where
+  "hreal_sub == %Y X. hreal (%w. EX x. ~ cut X x & cut Y (hrat_add x w))"
+
+lemma hreal_sub: "hreal_sub Y X = hreal (%w. EX x. ~ cut X x & cut Y (hrat_add x w))"
+  sorry
+
+lemma HREAL_LT_LEMMA: "hreal_lt X Y ==> EX x. ~ cut X x & cut Y x"
+  sorry
+
+lemma HREAL_SUB_ISACUT: "hreal_lt X Y ==> isacut (%w. EX x. ~ cut X x & cut Y (hrat_add x w))"
+  sorry
+
+lemma HREAL_SUB_ADD: "hreal_lt X Y ==> hreal_add (hreal_sub Y X) X = Y"
+  sorry
+
+lemma HREAL_LT_TOTAL: "X = Y | hreal_lt X Y | hreal_lt Y X"
+  sorry
+
+lemma HREAL_LT: "hreal_lt X Y = (EX D. Y = hreal_add X D)"
+  sorry
+
+lemma HREAL_ADD_TOTAL: "X = Y | (EX D. Y = hreal_add X D) | (EX D. X = hreal_add Y D)"
+  sorry
+
+lemma HREAL_SUP_ISACUT: "Ex P & (EX Y. ALL X. P X --> hreal_lt X Y)
+==> isacut (%w. EX X. P X & cut X w)"
+  sorry
+
+lemma HREAL_SUP: "Ex P & (EX Y. ALL X. P X --> hreal_lt X Y)
+==> (EX X. P X & hreal_lt Y X) = hreal_lt Y (hreal_sup P)"
+  sorry
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" numeral
+
+lemma numeral_suc: "Suc ALT_ZERO = NUMERAL_BIT1 ALT_ZERO &
+(ALL x. Suc (NUMERAL_BIT1 x) = NUMERAL_BIT2 x) &
+(ALL x. Suc (NUMERAL_BIT2 x) = NUMERAL_BIT1 (Suc x))"
+  sorry
+
+definition
+  iZ :: "nat => nat"  where
+  "iZ == %x. x"
+
+lemma iZ: "iZ x = x"
+  sorry
+
+definition
+  iiSUC :: "nat => nat"  where
+  "iiSUC == %n. Suc (Suc n)"
+
+lemma iiSUC: "iiSUC n = Suc (Suc n)"
+  sorry
+
+lemma numeral_distrib: "(ALL x::nat. (0::nat) + x = x) &
+(ALL x::nat. x + (0::nat) = x) &
+(ALL (x::nat) xa::nat. NUMERAL x + NUMERAL xa = NUMERAL (iZ (x + xa))) &
+(ALL x::nat. (0::nat) * x = (0::nat)) &
+(ALL x::nat. x * (0::nat) = (0::nat)) &
+(ALL (x::nat) xa::nat. NUMERAL x * NUMERAL xa = NUMERAL (x * xa)) &
+(ALL x::nat. (0::nat) - x = (0::nat)) &
+(ALL x::nat. x - (0::nat) = x) &
+(ALL (x::nat) xa::nat. NUMERAL x - NUMERAL xa = NUMERAL (x - xa)) &
+(ALL x::nat. (0::nat) ^ NUMERAL (NUMERAL_BIT1 x) = (0::nat)) &
+(ALL x::nat. (0::nat) ^ NUMERAL (NUMERAL_BIT2 x) = (0::nat)) &
+(ALL x::nat. x ^ (0::nat) = (1::nat)) &
+(ALL (x::nat) xa::nat. NUMERAL x ^ NUMERAL xa = NUMERAL (x ^ xa)) &
+Suc (0::nat) = (1::nat) &
+(ALL x::nat. Suc (NUMERAL x) = NUMERAL (Suc x)) &
+PRE (0::nat) = (0::nat) &
+(ALL x::nat. PRE (NUMERAL x) = NUMERAL (PRE x)) &
+(ALL x::nat. (NUMERAL x = (0::nat)) = (x = ALT_ZERO)) &
+(ALL x::nat. ((0::nat) = NUMERAL x) = (x = ALT_ZERO)) &
+(ALL (x::nat) xa::nat. (NUMERAL x = NUMERAL xa) = (x = xa)) &
+(ALL x::nat. (x < (0::nat)) = False) &
+(ALL x::nat. ((0::nat) < NUMERAL x) = (ALT_ZERO < x)) &
+(ALL (x::nat) xa::nat. (NUMERAL x < NUMERAL xa) = (x < xa)) &
+(ALL x::nat. (x < (0::nat)) = False) &
+(ALL x::nat. ((0::nat) < NUMERAL x) = (ALT_ZERO < x)) &
+(ALL (x::nat) xa::nat. (NUMERAL xa < NUMERAL x) = (xa < x)) &
+(ALL x::nat. ((0::nat) <= x) = True) &
+(ALL x::nat. (NUMERAL x <= (0::nat)) = (x <= ALT_ZERO)) &
+(ALL (x::nat) xa::nat. (NUMERAL x <= NUMERAL xa) = (x <= xa)) &
+(ALL x::nat. ((0::nat) <= x) = True) &
+(ALL x::nat. (x <= (0::nat)) = (x = (0::nat))) &
+(ALL (x::nat) xa::nat. (NUMERAL xa <= NUMERAL x) = (xa <= x)) &
+(ALL x::nat. ODD (NUMERAL x) = ODD x) &
+(ALL x::nat. EVEN (NUMERAL x) = EVEN x) & ~ ODD (0::nat) & EVEN (0::nat)"
+  sorry
+
+lemma numeral_iisuc: "iiSUC ALT_ZERO = NUMERAL_BIT2 ALT_ZERO &
+iiSUC (NUMERAL_BIT1 n) = NUMERAL_BIT1 (Suc n) &
+iiSUC (NUMERAL_BIT2 n) = NUMERAL_BIT2 (Suc n)"
+  sorry
+
+lemma numeral_add: "iZ (ALT_ZERO + x) = x &
+iZ (x + ALT_ZERO) = x &
+iZ (NUMERAL_BIT1 x + NUMERAL_BIT1 xa) = NUMERAL_BIT2 (iZ (x + xa)) &
+iZ (NUMERAL_BIT1 x + NUMERAL_BIT2 xa) = NUMERAL_BIT1 (Suc (x + xa)) &
+iZ (NUMERAL_BIT2 x + NUMERAL_BIT1 xa) = NUMERAL_BIT1 (Suc (x + xa)) &
+iZ (NUMERAL_BIT2 x + NUMERAL_BIT2 xa) = NUMERAL_BIT2 (Suc (x + xa)) &
+Suc (ALT_ZERO + x) = Suc x &
+Suc (x + ALT_ZERO) = Suc x &
+Suc (NUMERAL_BIT1 x + NUMERAL_BIT1 xa) = NUMERAL_BIT1 (Suc (x + xa)) &
+Suc (NUMERAL_BIT1 x + NUMERAL_BIT2 xa) = NUMERAL_BIT2 (Suc (x + xa)) &
+Suc (NUMERAL_BIT2 x + NUMERAL_BIT1 xa) = NUMERAL_BIT2 (Suc (x + xa)) &
+Suc (NUMERAL_BIT2 x + NUMERAL_BIT2 xa) = NUMERAL_BIT1 (iiSUC (x + xa)) &
+iiSUC (ALT_ZERO + x) = iiSUC x &
+iiSUC (x + ALT_ZERO) = iiSUC x &
+iiSUC (NUMERAL_BIT1 x + NUMERAL_BIT1 xa) = NUMERAL_BIT2 (Suc (x + xa)) &
+iiSUC (NUMERAL_BIT1 x + NUMERAL_BIT2 xa) = NUMERAL_BIT1 (iiSUC (x + xa)) &
+iiSUC (NUMERAL_BIT2 x + NUMERAL_BIT1 xa) = NUMERAL_BIT1 (iiSUC (x + xa)) &
+iiSUC (NUMERAL_BIT2 x + NUMERAL_BIT2 xa) = NUMERAL_BIT2 (iiSUC (x + xa))"
+  sorry
+
+lemma numeral_eq: "(ALT_ZERO = NUMERAL_BIT1 x) = False &
+(NUMERAL_BIT1 x = ALT_ZERO) = False &
+(ALT_ZERO = NUMERAL_BIT2 x) = False &
+(NUMERAL_BIT2 x = ALT_ZERO) = False &
+(NUMERAL_BIT1 x = NUMERAL_BIT2 xa) = False &
+(NUMERAL_BIT2 x = NUMERAL_BIT1 xa) = False &
+(NUMERAL_BIT1 x = NUMERAL_BIT1 xa) = (x = xa) &
+(NUMERAL_BIT2 x = NUMERAL_BIT2 xa) = (x = xa)"
+  sorry
+
+lemma numeral_lt: "(ALT_ZERO < NUMERAL_BIT1 x) = True &
+(ALT_ZERO < NUMERAL_BIT2 x) = True &
+(x < ALT_ZERO) = False &
+(NUMERAL_BIT1 x < NUMERAL_BIT1 xa) = (x < xa) &
+(NUMERAL_BIT2 x < NUMERAL_BIT2 xa) = (x < xa) &
+(NUMERAL_BIT1 x < NUMERAL_BIT2 xa) = (~ xa < x) &
+(NUMERAL_BIT2 x < NUMERAL_BIT1 xa) = (x < xa)"
+  sorry
+
+lemma numeral_lte: "(ALT_ZERO <= x) = True &
+(NUMERAL_BIT1 x <= ALT_ZERO) = False &
+(NUMERAL_BIT2 x <= ALT_ZERO) = False &
+(NUMERAL_BIT1 x <= NUMERAL_BIT1 xa) = (x <= xa) &
+(NUMERAL_BIT1 x <= NUMERAL_BIT2 xa) = (x <= xa) &
+(NUMERAL_BIT2 x <= NUMERAL_BIT1 xa) = (~ xa <= x) &
+(NUMERAL_BIT2 x <= NUMERAL_BIT2 xa) = (x <= xa)"
+  sorry
+
+lemma numeral_pre: "PRE ALT_ZERO = ALT_ZERO &
+PRE (NUMERAL_BIT1 ALT_ZERO) = ALT_ZERO &
+(ALL x.
+    PRE (NUMERAL_BIT1 (NUMERAL_BIT1 x)) =
+    NUMERAL_BIT2 (PRE (NUMERAL_BIT1 x))) &
+(ALL x.
+    PRE (NUMERAL_BIT1 (NUMERAL_BIT2 x)) = NUMERAL_BIT2 (NUMERAL_BIT1 x)) &
+(ALL x. PRE (NUMERAL_BIT2 x) = NUMERAL_BIT1 x)"
+  sorry
+
+lemma bit_initiality: "EX x. x ALT_ZERO = zf &
+      (ALL n. x (NUMERAL_BIT1 n) = b1f n (x n)) &
+      (ALL n. x (NUMERAL_BIT2 n) = b2f n (x n))"
+  sorry
+
+consts
+  iBIT_cases :: "nat => 'a => (nat => 'a) => (nat => 'a) => 'a" 
+
+specification (iBIT_cases) iBIT_cases: "(ALL (zf::'a) (bf1::nat => 'a) bf2::nat => 'a.
+    iBIT_cases ALT_ZERO zf bf1 bf2 = zf) &
+(ALL (n::nat) (zf::'a) (bf1::nat => 'a) bf2::nat => 'a.
+    iBIT_cases (NUMERAL_BIT1 n) zf bf1 bf2 = bf1 n) &
+(ALL (n::nat) (zf::'a) (bf1::nat => 'a) bf2::nat => 'a.
+    iBIT_cases (NUMERAL_BIT2 n) zf bf1 bf2 = bf2 n)"
+  sorry
+
+definition
+  iDUB :: "nat => nat"  where
+  "iDUB == %x. x + x"
+
+lemma iDUB: "iDUB x = x + x"
+  sorry
+
+consts
+  iSUB :: "bool => nat => nat => nat" 
+
+specification (iSUB) iSUB_DEF: "(ALL b x. iSUB b ALT_ZERO x = ALT_ZERO) &
+(ALL b n x.
+    iSUB b (NUMERAL_BIT1 n) x =
+    (if b
+     then iBIT_cases x (NUMERAL_BIT1 n) (%m. iDUB (iSUB True n m))
+           (%m. NUMERAL_BIT1 (iSUB False n m))
+     else iBIT_cases x (iDUB n) (%m. NUMERAL_BIT1 (iSUB False n m))
+           (%m. iDUB (iSUB False n m)))) &
+(ALL b n x.
+    iSUB b (NUMERAL_BIT2 n) x =
+    (if b
+     then iBIT_cases x (NUMERAL_BIT2 n) (%m. NUMERAL_BIT1 (iSUB True n m))
+           (%m. iDUB (iSUB True n m))
+     else iBIT_cases x (NUMERAL_BIT1 n) (%m. iDUB (iSUB True n m))
+           (%m. NUMERAL_BIT1 (iSUB False n m))))"
+  sorry
+
+lemma bit_induction: "P ALT_ZERO &
+(ALL n. P n --> P (NUMERAL_BIT1 n)) & (ALL n. P n --> P (NUMERAL_BIT2 n))
+==> P x"
+  sorry
+
+lemma iSUB_THM: "iSUB (x::bool) ALT_ZERO (xn::nat) = ALT_ZERO &
+iSUB True (xa::nat) ALT_ZERO = xa &
+iSUB False (NUMERAL_BIT1 xa) ALT_ZERO = iDUB xa &
+iSUB True (NUMERAL_BIT1 xa) (NUMERAL_BIT1 (xb::nat)) =
+iDUB (iSUB True xa xb) &
+iSUB False (NUMERAL_BIT1 xa) (NUMERAL_BIT1 xb) =
+NUMERAL_BIT1 (iSUB False xa xb) &
+iSUB True (NUMERAL_BIT1 xa) (NUMERAL_BIT2 xb) =
+NUMERAL_BIT1 (iSUB False xa xb) &
+iSUB False (NUMERAL_BIT1 xa) (NUMERAL_BIT2 xb) = iDUB (iSUB False xa xb) &
+iSUB False (NUMERAL_BIT2 xa) ALT_ZERO = NUMERAL_BIT1 xa &
+iSUB True (NUMERAL_BIT2 xa) (NUMERAL_BIT1 xb) =
+NUMERAL_BIT1 (iSUB True xa xb) &
+iSUB False (NUMERAL_BIT2 xa) (NUMERAL_BIT1 xb) = iDUB (iSUB True xa xb) &
+iSUB True (NUMERAL_BIT2 xa) (NUMERAL_BIT2 xb) = iDUB (iSUB True xa xb) &
+iSUB False (NUMERAL_BIT2 xa) (NUMERAL_BIT2 xb) =
+NUMERAL_BIT1 (iSUB False xa xb)"
+  sorry
+
+lemma numeral_sub: "NUMERAL (x - xa) = (if xa < x then NUMERAL (iSUB True x xa) else 0)"
+  sorry
+
+lemma iDUB_removal: "iDUB (NUMERAL_BIT1 x) = NUMERAL_BIT2 (iDUB x) &
+iDUB (NUMERAL_BIT2 x) = NUMERAL_BIT2 (NUMERAL_BIT1 x) &
+iDUB ALT_ZERO = ALT_ZERO"
+  sorry
+
+lemma numeral_mult: "ALT_ZERO * x = ALT_ZERO &
+x * ALT_ZERO = ALT_ZERO &
+NUMERAL_BIT1 x * xa = iZ (iDUB (x * xa) + xa) &
+NUMERAL_BIT2 x * xa = iDUB (iZ (x * xa + xa))"
+  sorry
+
+definition
+  iSQR :: "nat => nat"  where
+  "iSQR == %x. x * x"
+
+lemma iSQR: "iSQR x = x * x"
+  sorry
+
+lemma numeral_exp: "(ALL x. x ^ ALT_ZERO = NUMERAL_BIT1 ALT_ZERO) &
+(ALL x xa. x ^ NUMERAL_BIT1 xa = x * iSQR (x ^ xa)) &
+(ALL x xa. x ^ NUMERAL_BIT2 xa = iSQR x * iSQR (x ^ xa))"
+  sorry
+
+lemma numeral_evenodd: "EVEN ALT_ZERO &
+EVEN (NUMERAL_BIT2 x) &
+~ EVEN (NUMERAL_BIT1 x) &
+~ ODD ALT_ZERO & ~ ODD (NUMERAL_BIT2 x) & ODD (NUMERAL_BIT1 x)"
+  sorry
+
+lemma numeral_fact: "FACT n = (if n = 0 then 1 else n * FACT (PRE n))"
+  sorry
+
+lemma numeral_funpow: "(f ^^ n) x = (if n = 0 then x else (f ^^ (n - 1)) (f x))"
+  sorry
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" ind_type
+
+lemma INJ_INVERSE2: "(!!(x1::'A) (y1::'B) (x2::'A) y2::'B.
+    ((P::'A => 'B => 'C) x1 y1 = P x2 y2) = (x1 = x2 & y1 = y2))
+==> EX (x::'C => 'A) Y::'C => 'B.
+       ALL (xa::'A) y::'B. x (P xa y) = xa & Y (P xa y) = y"
+  sorry
+
+definition
+  NUMPAIR :: "nat => nat => nat"  where
+  "NUMPAIR == %x y. 2 ^ x * (2 * y + 1)"
+
+lemma NUMPAIR: "NUMPAIR x y = 2 ^ x * (2 * y + 1)"
+  sorry
+
+lemma NUMPAIR_INJ_LEMMA: "NUMPAIR x xa = NUMPAIR xb xc ==> x = xb"
+  sorry
+
+lemma NUMPAIR_INJ: "(NUMPAIR x1 y1 = NUMPAIR x2 y2) = (x1 = x2 & y1 = y2)"
+  sorry
+
+consts
+  NUMSND :: "nat => nat" 
+  NUMFST :: "nat => nat" 
+
+specification (NUMFST NUMSND) NUMPAIR_DEST: "ALL x y. NUMFST (NUMPAIR x y) = x & NUMSND (NUMPAIR x y) = y"
+  sorry
+
+definition
+  NUMSUM :: "bool => nat => nat"  where
+  "NUMSUM == %b x. if b then Suc (2 * x) else 2 * x"
+
+lemma NUMSUM: "NUMSUM b x = (if b then Suc (2 * x) else 2 * x)"
+  sorry
+
+lemma NUMSUM_INJ: "(NUMSUM b1 x1 = NUMSUM b2 x2) = (b1 = b2 & x1 = x2)"
+  sorry
+
+consts
+  NUMRIGHT :: "nat => nat" 
+  NUMLEFT :: "nat => bool" 
+
+specification (NUMLEFT NUMRIGHT) NUMSUM_DEST: "ALL x y. NUMLEFT (NUMSUM x y) = x & NUMRIGHT (NUMSUM x y) = y"
+  sorry
+
+definition
+  INJN :: "nat => nat => 'a => bool"  where
+  "INJN == %m n a. n = m"
+
+lemma INJN: "INJN m = (%n a. n = m)"
+  sorry
+
+lemma INJN_INJ: "(INJN n1 = INJN n2) = (n1 = n2)"
+  sorry
+
+definition
+  INJA :: "'a => nat => 'a => bool"  where
+  "INJA == %a n b. b = a"
+
+lemma INJA: "INJA a = (%n b. b = a)"
+  sorry
+
+lemma INJA_INJ: "(INJA a1 = INJA a2) = (a1 = a2)"
+  sorry
+
+definition
+  INJF :: "(nat => nat => 'a => bool) => nat => 'a => bool"  where
+  "INJF == %f n. f (NUMFST n) (NUMSND n)"
+
+lemma INJF: "INJF f = (%n. f (NUMFST n) (NUMSND n))"
+  sorry
+
+lemma INJF_INJ: "(INJF f1 = INJF f2) = (f1 = f2)"
+  sorry
+
+definition
+  INJP :: "(nat => 'a => bool) => (nat => 'a => bool) => nat => 'a => bool"  where
+  "INJP ==
+%f1 f2 n a. if NUMLEFT n then f1 (NUMRIGHT n) a else f2 (NUMRIGHT n) a"
+
+lemma INJP: "INJP f1 f2 =
+(%n a. if NUMLEFT n then f1 (NUMRIGHT n) a else f2 (NUMRIGHT n) a)"
+  sorry
+
+lemma INJP_INJ: "(INJP f1 f2 = INJP f1' f2') = (f1 = f1' & f2 = f2')"
+  sorry
+
+definition
+  ZCONSTR :: "nat => 'a => (nat => nat => 'a => bool) => nat => 'a => bool"  where
+  "ZCONSTR == %c i r. INJP (INJN (Suc c)) (INJP (INJA i) (INJF r))"
+
+lemma ZCONSTR: "ZCONSTR c i r = INJP (INJN (Suc c)) (INJP (INJA i) (INJF r))"
+  sorry
+
+definition
+  ZBOT :: "nat => 'a => bool"  where
+  "ZBOT == INJP (INJN 0) (SOME z. True)"
+
+lemma ZBOT: "ZBOT = INJP (INJN 0) (SOME z. True)"
+  sorry
+
+lemma ZCONSTR_ZBOT: "ZCONSTR x xa xb ~= ZBOT"
+  sorry
+
+definition
+  ZRECSPACE :: "(nat => 'a => bool) => bool"  where
+  "ZRECSPACE ==
+%a0. ALL ZRECSPACE'.
+        (ALL a0.
+            a0 = ZBOT |
+            (EX c i r. a0 = ZCONSTR c i r & (ALL n. ZRECSPACE' (r n))) -->
+            ZRECSPACE' a0) -->
+        ZRECSPACE' a0"
+
+lemma ZRECSPACE: "ZRECSPACE =
+(%a0. ALL ZRECSPACE'.
+         (ALL a0.
+             a0 = ZBOT |
+             (EX c i r. a0 = ZCONSTR c i r & (ALL n. ZRECSPACE' (r n))) -->
+             ZRECSPACE' a0) -->
+         ZRECSPACE' a0)"
+  sorry
+
+lemma ZRECSPACE_rules: "(op &::bool => bool => bool)
+ ((ZRECSPACE::(nat => 'a::type => bool) => bool)
+   (ZBOT::nat => 'a::type => bool))
+ ((All::(nat => bool) => bool)
+   (%c::nat.
+       (All::('a::type => bool) => bool)
+        (%i::'a::type.
+            (All::((nat => nat => 'a::type => bool) => bool) => bool)
+             (%r::nat => nat => 'a::type => bool.
+                 (op -->::bool => bool => bool)
+                  ((All::(nat => bool) => bool)
+                    (%n::nat.
+                        (ZRECSPACE::(nat => 'a::type => bool) => bool)
+                         (r n)))
+                  ((ZRECSPACE::(nat => 'a::type => bool) => bool)
+                    ((ZCONSTR::nat
+                               => 'a::type
+                                  => (nat => nat => 'a::type => bool)
+                                     => nat => 'a::type => bool)
+                      c i r))))))"
+  sorry
+
+lemma ZRECSPACE_ind: "[| x ZBOT & (ALL c i r. (ALL n. x (r n)) --> x (ZCONSTR c i r));
+   ZRECSPACE a0 |]
+==> x a0"
+  sorry
+
+lemma ZRECSPACE_cases: "ZRECSPACE a0 =
+(a0 = ZBOT | (EX c i r. a0 = ZCONSTR c i r & (ALL n. ZRECSPACE (r n))))"
+  sorry
+
+typedef (open) ('a) recspace = "Collect ZRECSPACE :: (nat \<Rightarrow> 'a\<Colon>type \<Rightarrow> bool) set"
+  sorry
+
+lemmas recspace_TY_DEF = typedef_hol2hol4 [OF type_definition_recspace]
+
+consts
+  mk_rec :: "(nat => 'a => bool) => 'a recspace" 
+  dest_rec :: "'a recspace => nat => 'a => bool" 
+
+specification (dest_rec mk_rec) recspace_repfns: "(ALL a::'a recspace. mk_rec (dest_rec a) = a) &
+(ALL r::nat => 'a => bool. ZRECSPACE r = (dest_rec (mk_rec r) = r))"
+  sorry
+
+definition
+  BOTTOM :: "'a recspace"  where
+  "BOTTOM == mk_rec ZBOT"
+
+lemma BOTTOM: "BOTTOM = mk_rec ZBOT"
+  sorry
+
+definition
+  CONSTR :: "nat => 'a => (nat => 'a recspace) => 'a recspace"  where
+  "CONSTR == %c i r. mk_rec (ZCONSTR c i (%n. dest_rec (r n)))"
+
+lemma CONSTR: "CONSTR c i r = mk_rec (ZCONSTR c i (%n. dest_rec (r n)))"
+  sorry
+
+lemma MK_REC_INJ: "[| mk_rec x = mk_rec y; ZRECSPACE x & ZRECSPACE y |] ==> x = y"
+  sorry
+
+lemma DEST_REC_INJ: "(dest_rec x = dest_rec y) = (x = y)"
+  sorry
+
+lemma CONSTR_BOT: "CONSTR c i r ~= BOTTOM"
+  sorry
+
+lemma CONSTR_INJ: "(CONSTR c1 i1 r1 = CONSTR c2 i2 r2) = (c1 = c2 & i1 = i2 & r1 = r2)"
+  sorry
+
+lemma CONSTR_IND: "P BOTTOM & (ALL c i r. (ALL n. P (r n)) --> P (CONSTR c i r)) ==> P x"
+  sorry
+
+lemma CONSTR_REC: "EX f. ALL c i r. f (CONSTR c i r) = Fn c i r (%n. f (r n))"
+  sorry
+
+consts
+  FCONS :: "'a => (nat => 'a) => nat => 'a" 
+
+specification (FCONS) FCONS: "(ALL (a::'a) f::nat => 'a. FCONS a f (0::nat) = a) &
+(ALL (a::'a) (f::nat => 'a) n::nat. FCONS a f (Suc n) = f n)"
+  sorry
+
+definition
+  FNIL :: "nat => 'a"  where
+  "FNIL == %n. SOME x. True"
+
+lemma FNIL: "FNIL n = (SOME x. True)"
+  sorry
+
+definition
+  ISO :: "('a => 'b) => ('b => 'a) => bool"  where
+  "ISO == %f g. (ALL x. f (g x) = x) & (ALL y. g (f y) = y)"
+
+lemma ISO: "ISO f g = ((ALL x. f (g x) = x) & (ALL y. g (f y) = y))"
+  sorry
+
+lemma ISO_REFL: "ISO (%x. x) (%x. x)"
+  sorry
+
+lemma ISO_FUN: "ISO (f::'a => 'c) (f'::'c => 'a) & ISO (g::'b => 'd) (g'::'d => 'b)
+==> ISO (%(h::'a => 'b) a'::'c. g (h (f' a')))
+     (%(h::'c => 'd) a::'a. g' (h (f a)))"
+  sorry
+
+lemma ISO_USAGE: "ISO f g
+==> (ALL P. All P = (ALL x. P (g x))) &
+    (ALL P. Ex P = (EX x. P (g x))) & (ALL a b. (a = g b) = (f a = b))"
+  sorry
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" divides
+
+lemma DIVIDES_FACT: "0 < b ==> b dvd FACT b"
+  sorry
+
+lemma DIVIDES_MULT_LEFT: "((x::nat) * (xa::nat) dvd xa) = (xa = (0::nat) | x = (1::nat))"
+  sorry
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" prime
+
+consts
+  prime :: "nat => bool" 
+
+defs
+  prime_primdef: "prime.prime == %a. a ~= 1 & (ALL b. b dvd a --> b = a | b = 1)"
+
+lemma prime_def: "prime.prime a = (a ~= 1 & (ALL b. b dvd a --> b = a | b = 1))"
+  sorry
+
+lemma NOT_PRIME_0: "~ prime.prime 0"
+  sorry
+
+lemma NOT_PRIME_1: "~ prime.prime 1"
+  sorry
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" list
+
+consts
+  EL :: "nat => 'a list => 'a" 
+
+specification (EL) EL: "(ALL l::'a list. EL (0::nat) l = hd l) &
+(ALL (l::'a list) n::nat. EL (Suc n) l = EL n (tl l))"
+  sorry
+
+lemma NULL: "(op &::bool => bool => bool)
+ ((List.null::'a::type list => bool) ([]::'a::type list))
+ ((All::('a::type => bool) => bool)
+   (%x::'a::type.
+       (All::('a::type list => bool) => bool)
+        (%xa::'a::type list.
+            (Not::bool => bool)
+             ((List.null::'a::type list => bool)
+               ((op #::'a::type => 'a::type list => 'a::type list) x xa)))))"
+  sorry
+
+lemma list_case_compute: "list_case (b::'b) (f::'a => 'a list => 'b) (l::'a list) =
+(if List.null l then b else f (hd l) (tl l))"
+  sorry
+
+lemma LIST_NOT_EQ: "l1 ~= l2 ==> x # l1 ~= xa # l2"
+  sorry
+
+lemma NOT_EQ_LIST: "h1 ~= h2 ==> h1 # x ~= h2 # xa"
+  sorry
+
+lemma EQ_LIST: "[| h1 = h2; l1 = l2 |] ==> h1 # l1 = h2 # l2"
+  sorry
+
+lemma CONS: "~ List.null l ==> hd l # tl l = l"
+  sorry
+
+lemma MAP_EQ_NIL: "(map (f::'a => 'b) (l::'a list) = []) = (l = []) & ([] = map f l) = (l = [])"
+  sorry
+
+lemma EVERY_EL: "list_all P l = (ALL n<length l. P (EL n l))"
+  sorry
+
+lemma EVERY_CONJ: "list_all (%x. P x & Q x) l = (list_all P l & list_all Q l)"
+  sorry
+
+lemma EVERY_MEM: "list_all P l = (ALL e. List.member l e --> P e)"
+  sorry
+
+lemma EXISTS_MEM: "list_ex P l = (EX e. List.member l e & P e)"
+  sorry
+
+lemma MEM_APPEND: "List.member (l1 @ l2) e = (List.member l1 e | List.member l2 e)"
+  sorry
+
+lemma NOT_EVERY: "(~ list_all P l) = list_ex (Not o P) l"
+  sorry
+
+lemma NOT_EXISTS: "(~ list_ex P l) = list_all (Not o P) l"
+  sorry
+
+lemma MEM_MAP: "List.member (map (f::'a => 'b) (l::'a list)) (x::'b) =
+(EX y::'a. x = f y & List.member l y)"
+  sorry
+
+lemma LENGTH_CONS: "(length l = Suc n) = (EX h l'. length l' = n & l = h # l')"
+  sorry
+
+lemma LENGTH_EQ_CONS: "(ALL l. length l = Suc n --> P l) =
+(ALL l. length l = n --> (ALL x. P (x # l)))"
+  sorry
+
+lemma LENGTH_EQ_NIL: "(ALL l. length l = 0 --> P l) = P []"
+  sorry
+
+lemma CONS_ACYCLIC: "l ~= x # l & x # l ~= l"
+  sorry
+
+lemma APPEND_eq_NIL: "(ALL (l1::'a list) l2::'a list. ([] = l1 @ l2) = (l1 = [] & l2 = [])) &
+(ALL (l1::'a list) l2::'a list. (l1 @ l2 = []) = (l1 = [] & l2 = []))"
+  sorry
+
+lemma APPEND_11: "(ALL (l1::'a list) (l2::'a list) l3::'a list.
+    (l1 @ l2 = l1 @ l3) = (l2 = l3)) &
+(ALL (l1::'a list) (l2::'a list) l3::'a list.
+    (l2 @ l1 = l3 @ l1) = (l2 = l3))"
+  sorry
+
+lemma EL_compute: "EL n l = (if n = 0 then hd l else EL (PRE n) (tl l))"
+  sorry
+
+lemma WF_LIST_PRED: "WF (%L1 L2. EX h. L2 = h # L1)"
+  sorry
+
+lemma list_size_cong: "M = N & (ALL x. List.member N x --> f x = f' x)
+==> Compatibility.list_size f M = Compatibility.list_size f' N"
+  sorry
+
+lemma FOLDR_CONG: "l = l' & b = b' & (ALL x a. List.member l' x --> f x a = f' x a)
+==> foldr f l b = foldr f' l' b'"
+  sorry
+
+lemma FOLDL_CONG: "l = l' & b = b' & (ALL x a. List.member l' x --> f a x = f' a x)
+==> foldl f b l = foldl f' b' l'"
+  sorry
+
+lemma MAP_CONG: "l1 = l2 & (ALL x. List.member l2 x --> f x = f' x) ==> map f l1 = map f' l2"
+  sorry
+
+lemma EXISTS_CONG: "l1 = l2 & (ALL x. List.member l2 x --> P x = P' x)
+==> list_ex P l1 = list_ex P' l2"
+  sorry
+
+lemma EVERY_CONG: "l1 = l2 & (ALL x. List.member l2 x --> P x = P' x)
+==> list_all P l1 = list_all P' l2"
+  sorry
+
+lemma EVERY_MONOTONIC: "[| !!x. P x ==> Q x; list_all P l |] ==> list_all Q l"
+  sorry
+
+lemma LENGTH_ZIP: "length l1 = length l2
+==> length (zip l1 l2) = length l1 & length (zip l1 l2) = length l2"
+  sorry
+
+lemma LENGTH_UNZIP: "length (fst (unzip pl)) = length pl & length (snd (unzip pl)) = length pl"
+  sorry
+
+lemma ZIP_UNZIP: "ZIP (unzip l) = l"
+  sorry
+
+lemma UNZIP_ZIP: "length l1 = length l2 ==> unzip (zip l1 l2) = (l1, l2)"
+  sorry
+
+lemma ZIP_MAP: "length l1 = length l2
+==> zip (map f1 l1) l2 = map (%p. (f1 (fst p), snd p)) (zip l1 l2) &
+    zip l1 (map f2 l2) = map (%p. (fst p, f2 (snd p))) (zip l1 l2)"
+  sorry
+
+lemma MEM_ZIP: "length l1 = length l2
+==> List.member (zip l1 l2) p = (EX n<length l1. p = (EL n l1, EL n l2))"
+  sorry
+
+lemma EL_ZIP: "length l1 = length l2 & n < length l1
+==> EL n (zip l1 l2) = (EL n l1, EL n l2)"
+  sorry
+
+lemma MAP2_ZIP: "length l1 = length l2 ==> map2 f l1 l2 = map (%(x, y). f x y) (zip l1 l2)"
+  sorry
+
+lemma MEM_EL: "List.member l x = (EX n<length l. x = EL n l)"
+  sorry
+
+lemma LAST_CONS: "(ALL x::'a. last [x] = x) &
+(ALL (x::'a) (xa::'a) xb::'a list. last (x # xa # xb) = last (xa # xb))"
+  sorry
+
+lemma FRONT_CONS: "(ALL x::'a. butlast [x] = []) &
+(ALL (x::'a) (xa::'a) xb::'a list.
+    butlast (x # xa # xb) = x # butlast (xa # xb))"
+  sorry
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" pred_set
+
+lemma EXTENSION: "(s = t) = (ALL x. IN x s = IN x t)"
+  sorry
+
+lemma NOT_EQUAL_SETS: "(x ~= xa) = (EX xb. IN xb xa = (~ IN xb x))"
+  sorry
+
+lemma NUM_SET_WOP: "(EX n::nat. IN n (s::nat => bool)) =
+(EX n::nat. IN n s & (ALL m::nat. IN m s --> n <= m))"
+  sorry
+
+consts
+  GSPEC :: "('b => 'a * bool) => 'a => bool" 
+
+specification (GSPEC) GSPECIFICATION: "ALL (f::'b => 'a * bool) v::'a. IN v (GSPEC f) = (EX x::'b. (v, True) = f x)"
+  sorry
+
+lemma SET_MINIMUM: "(EX x::'a. IN x (s::'a => bool)) =
+(EX x::'a. IN x s & (ALL y::'a. IN y s --> (M::'a => nat) x <= M y))"
+  sorry
+
+definition
+  EMPTY :: "'a => bool"  where
+  "EMPTY == %x. False"
+
+lemma EMPTY_DEF: "EMPTY = (%x. False)"
+  sorry
+
+lemma NOT_IN_EMPTY: "~ IN x EMPTY"
+  sorry
+
+lemma MEMBER_NOT_EMPTY: "(EX xa. IN xa x) = (x ~= EMPTY)"
+  sorry
+
+definition
+  UNIV :: "'a => bool"  where
+  "UNIV == %x. True"
+
+lemma UNIV_DEF: "pred_set.UNIV = (%x. True)"
+  sorry
+
+lemma IN_UNIV: "IN x pred_set.UNIV"
+  sorry
+
+lemma UNIV_NOT_EMPTY: "pred_set.UNIV ~= EMPTY"
+  sorry
+
+lemma EMPTY_NOT_UNIV: "EMPTY ~= pred_set.UNIV"
+  sorry
+
+lemma EQ_UNIV: "(ALL x. IN x s) = (s = pred_set.UNIV)"
+  sorry
+
+definition
+  SUBSET :: "('a => bool) => ('a => bool) => bool"  where
+  "SUBSET == %s t. ALL x. IN x s --> IN x t"
+
+lemma SUBSET_DEF: "SUBSET s t = (ALL x. IN x s --> IN x t)"
+  sorry
+
+lemma SUBSET_TRANS: "SUBSET x xa & SUBSET xa xb ==> SUBSET x xb"
+  sorry
+
+lemma SUBSET_REFL: "SUBSET x x"
+  sorry
+
+lemma SUBSET_ANTISYM: "SUBSET x xa & SUBSET xa x ==> x = xa"
+  sorry
+
+lemma EMPTY_SUBSET: "SUBSET EMPTY x"
+  sorry
+
+lemma SUBSET_EMPTY: "SUBSET x EMPTY = (x = EMPTY)"
+  sorry
+
+lemma SUBSET_UNIV: "SUBSET x pred_set.UNIV"
+  sorry
+
+lemma UNIV_SUBSET: "SUBSET pred_set.UNIV x = (x = pred_set.UNIV)"
+  sorry
+
+definition
+  PSUBSET :: "('a => bool) => ('a => bool) => bool"  where
+  "PSUBSET == %s t. SUBSET s t & s ~= t"
+
+lemma PSUBSET_DEF: "PSUBSET s t = (SUBSET s t & s ~= t)"
+  sorry
+
+lemma PSUBSET_TRANS: "PSUBSET x xa & PSUBSET xa xb ==> PSUBSET x xb"
+  sorry
+
+lemma PSUBSET_IRREFL: "~ PSUBSET x x"
+  sorry
+
+lemma NOT_PSUBSET_EMPTY: "~ PSUBSET x EMPTY"
+  sorry
+
+lemma NOT_UNIV_PSUBSET: "~ PSUBSET pred_set.UNIV x"
+  sorry
+
+lemma PSUBSET_UNIV: "PSUBSET x pred_set.UNIV = (EX xa. ~ IN xa x)"
+  sorry
+
+definition
+  UNION :: "('a => bool) => ('a => bool) => 'a => bool"  where
+  "UNION == %s t. GSPEC (%x. (x, IN x s | IN x t))"
+
+lemma UNION_DEF: "pred_set.UNION s t = GSPEC (%x. (x, IN x s | IN x t))"
+  sorry
+
+lemma IN_UNION: "IN xb (pred_set.UNION x xa) = (IN xb x | IN xb xa)"
+  sorry
+
+lemma UNION_ASSOC: "pred_set.UNION x (pred_set.UNION xa xb) =
+pred_set.UNION (pred_set.UNION x xa) xb"
+  sorry
+
+lemma UNION_IDEMPOT: "pred_set.UNION x x = x"
+  sorry
+
+lemma UNION_COMM: "pred_set.UNION x xa = pred_set.UNION xa x"
+  sorry
+
+lemma SUBSET_UNION: "(ALL (x::'a => bool) xa::'a => bool. SUBSET x (pred_set.UNION x xa)) &
+(ALL (x::'a => bool) xa::'a => bool. SUBSET x (pred_set.UNION xa x))"
+  sorry
+
+lemma UNION_SUBSET: "SUBSET (pred_set.UNION s t) u = (SUBSET s u & SUBSET t u)"
+  sorry
+
+lemma SUBSET_UNION_ABSORPTION: "SUBSET x xa = (pred_set.UNION x xa = xa)"
+  sorry
+
+lemma UNION_EMPTY: "(ALL x::'a => bool. pred_set.UNION EMPTY x = x) &
+(ALL x::'a => bool. pred_set.UNION x EMPTY = x)"
+  sorry
+
+lemma UNION_UNIV: "(ALL x::'a => bool. pred_set.UNION pred_set.UNIV x = pred_set.UNIV) &
+(ALL x::'a => bool. pred_set.UNION x pred_set.UNIV = pred_set.UNIV)"
+  sorry
+
+lemma EMPTY_UNION: "(pred_set.UNION x xa = EMPTY) = (x = EMPTY & xa = EMPTY)"
+  sorry
+
+definition
+  INTER :: "('a => bool) => ('a => bool) => 'a => bool"  where
+  "INTER == %s t. GSPEC (%x. (x, IN x s & IN x t))"
+
+lemma INTER_DEF: "pred_set.INTER s t = GSPEC (%x. (x, IN x s & IN x t))"
+  sorry
+
+lemma IN_INTER: "IN xb (pred_set.INTER x xa) = (IN xb x & IN xb xa)"
+  sorry
+
+lemma INTER_ASSOC: "pred_set.INTER x (pred_set.INTER xa xb) =
+pred_set.INTER (pred_set.INTER x xa) xb"
+  sorry
+
+lemma INTER_IDEMPOT: "pred_set.INTER x x = x"
+  sorry
+
+lemma INTER_COMM: "pred_set.INTER x xa = pred_set.INTER xa x"
+  sorry
+
+lemma INTER_SUBSET: "(ALL (x::'a => bool) xa::'a => bool. SUBSET (pred_set.INTER x xa) x) &
+(ALL (x::'a => bool) xa::'a => bool. SUBSET (pred_set.INTER xa x) x)"
+  sorry
+
+lemma SUBSET_INTER: "SUBSET s (pred_set.INTER t u) = (SUBSET s t & SUBSET s u)"
+  sorry
+
+lemma SUBSET_INTER_ABSORPTION: "SUBSET x xa = (pred_set.INTER x xa = x)"
+  sorry
+
+lemma INTER_EMPTY: "(ALL x::'a => bool. pred_set.INTER EMPTY x = EMPTY) &
+(ALL x::'a => bool. pred_set.INTER x EMPTY = EMPTY)"
+  sorry
+
+lemma INTER_UNIV: "(ALL x::'a => bool. pred_set.INTER pred_set.UNIV x = x) &
+(ALL x::'a => bool. pred_set.INTER x pred_set.UNIV = x)"
+  sorry
+
+lemma UNION_OVER_INTER: "pred_set.INTER x (pred_set.UNION xa xb) =
+pred_set.UNION (pred_set.INTER x xa) (pred_set.INTER x xb)"
+  sorry
+
+lemma INTER_OVER_UNION: "pred_set.UNION x (pred_set.INTER xa xb) =
+pred_set.INTER (pred_set.UNION x xa) (pred_set.UNION x xb)"
+  sorry
+
+definition
+  DISJOINT :: "('a => bool) => ('a => bool) => bool"  where
+  "DISJOINT == %s t. pred_set.INTER s t = EMPTY"
+
+lemma DISJOINT_DEF: "DISJOINT s t = (pred_set.INTER s t = EMPTY)"
+  sorry
+
+lemma IN_DISJOINT: "DISJOINT x xa = (~ (EX xb. IN xb x & IN xb xa))"
+  sorry
+
+lemma DISJOINT_SYM: "DISJOINT x xa = DISJOINT xa x"
+  sorry
+
+lemma DISJOINT_EMPTY: "DISJOINT EMPTY x & DISJOINT x EMPTY"
+  sorry
+
+lemma DISJOINT_EMPTY_REFL: "(x = EMPTY) = DISJOINT x x"
+  sorry
+
+lemma DISJOINT_UNION: "DISJOINT (pred_set.UNION x xa) xb = (DISJOINT x xb & DISJOINT xa xb)"
+  sorry
+
+lemma DISJOINT_UNION_BOTH: "DISJOINT (pred_set.UNION s t) u = (DISJOINT s u & DISJOINT t u) &
+DISJOINT u (pred_set.UNION s t) = (DISJOINT s u & DISJOINT t u)"
+  sorry
+
+definition
+  DIFF :: "('a => bool) => ('a => bool) => 'a => bool"  where
+  "DIFF == %s t. GSPEC (%x. (x, IN x s & ~ IN x t))"
+
+lemma DIFF_DEF: "DIFF s t = GSPEC (%x. (x, IN x s & ~ IN x t))"
+  sorry
+
+lemma IN_DIFF: "IN x (DIFF s t) = (IN x s & ~ IN x t)"
+  sorry
+
+lemma DIFF_EMPTY: "DIFF s EMPTY = s"
+  sorry
+
+lemma EMPTY_DIFF: "DIFF EMPTY s = EMPTY"
+  sorry
+
+lemma DIFF_UNIV: "DIFF s pred_set.UNIV = EMPTY"
+  sorry
+
+lemma DIFF_DIFF: "DIFF (DIFF x xa) xa = DIFF x xa"
+  sorry
+
+lemma DIFF_EQ_EMPTY: "DIFF x x = EMPTY"
+  sorry
+
+definition
+  INSERT :: "'a => ('a => bool) => 'a => bool"  where
+  "INSERT == %x s. GSPEC (%y. (y, y = x | IN y s))"
+
+lemma INSERT_DEF: "INSERT x s = GSPEC (%y. (y, y = x | IN y s))"
+  sorry
+
+lemma IN_INSERT: "IN x (INSERT xa xb) = (x = xa | IN x xb)"
+  sorry
+
+lemma COMPONENT: "IN x (INSERT x xa)"
+  sorry
+
+lemma SET_CASES: "x = EMPTY | (EX xa xb. x = INSERT xa xb & ~ IN xa xb)"
+  sorry
+
+lemma DECOMPOSITION: "IN x s = (EX t. s = INSERT x t & ~ IN x t)"
+  sorry
+
+lemma ABSORPTION: "IN x xa = (INSERT x xa = xa)"
+  sorry
+
+lemma INSERT_INSERT: "INSERT x (INSERT x xa) = INSERT x xa"
+  sorry
+
+lemma INSERT_COMM: "INSERT x (INSERT xa xb) = INSERT xa (INSERT x xb)"
+  sorry
+
+lemma INSERT_UNIV: "INSERT x pred_set.UNIV = pred_set.UNIV"
+  sorry
+
+lemma NOT_INSERT_EMPTY: "INSERT x xa ~= EMPTY"
+  sorry
+
+lemma NOT_EMPTY_INSERT: "EMPTY ~= INSERT x xa"
+  sorry
+
+lemma INSERT_UNION: "pred_set.UNION (INSERT x s) t =
+(if IN x t then pred_set.UNION s t else INSERT x (pred_set.UNION s t))"
+  sorry
+
+lemma INSERT_UNION_EQ: "pred_set.UNION (INSERT x s) t = INSERT x (pred_set.UNION s t)"
+  sorry
+
+lemma INSERT_INTER: "pred_set.INTER (INSERT x s) t =
+(if IN x t then INSERT x (pred_set.INTER s t) else pred_set.INTER s t)"
+  sorry
+
+lemma DISJOINT_INSERT: "DISJOINT (INSERT x xa) xb = (DISJOINT xa xb & ~ IN x xb)"
+  sorry
+
+lemma INSERT_SUBSET: "SUBSET (INSERT x xa) xb = (IN x xb & SUBSET xa xb)"
+  sorry
+
+lemma SUBSET_INSERT: "~ IN x xa ==> SUBSET xa (INSERT x xb) = SUBSET xa xb"
+  sorry
+
+lemma INSERT_DIFF: "DIFF (INSERT x s) t = (if IN x t then DIFF s t else INSERT x (DIFF s t))"
+  sorry
+
+definition
+  DELETE :: "('a => bool) => 'a => 'a => bool"  where
+  "DELETE == %s x. DIFF s (INSERT x EMPTY)"
+
+lemma DELETE_DEF: "DELETE s x = DIFF s (INSERT x EMPTY)"
+  sorry
+
+lemma IN_DELETE: "IN xa (DELETE x xb) = (IN xa x & xa ~= xb)"
+  sorry
+
+lemma DELETE_NON_ELEMENT: "(~ IN x xa) = (DELETE xa x = xa)"
+  sorry
+
+lemma IN_DELETE_EQ: "(IN x s = IN x' s) = (IN x (DELETE s x') = IN x' (DELETE s x))"
+  sorry
+
+lemma EMPTY_DELETE: "DELETE EMPTY x = EMPTY"
+  sorry
+
+lemma DELETE_DELETE: "DELETE (DELETE xa x) x = DELETE xa x"
+  sorry
+
+lemma DELETE_COMM: "DELETE (DELETE xb x) xa = DELETE (DELETE xb xa) x"
+  sorry
+
+lemma DELETE_SUBSET: "SUBSET (DELETE xa x) xa"
+  sorry
+
+lemma SUBSET_DELETE: "SUBSET xa (DELETE xb x) = (~ IN x xa & SUBSET xa xb)"
+  sorry
+
+lemma SUBSET_INSERT_DELETE: "SUBSET s (INSERT x t) = SUBSET (DELETE s x) t"
+  sorry
+
+lemma DIFF_INSERT: "DIFF x (INSERT xb xa) = DIFF (DELETE x xb) xa"
+  sorry
+
+lemma PSUBSET_INSERT_SUBSET: "PSUBSET x xa = (EX xb. ~ IN xb x & SUBSET (INSERT xb x) xa)"
+  sorry
+
+lemma PSUBSET_MEMBER: "PSUBSET s t = (SUBSET s t & (EX y. IN y t & ~ IN y s))"
+  sorry
+
+lemma DELETE_INSERT: "DELETE (INSERT x xb) xa =
+(if x = xa then DELETE xb xa else INSERT x (DELETE xb xa))"
+  sorry
+
+lemma INSERT_DELETE: "IN x xa ==> INSERT x (DELETE xa x) = xa"
+  sorry
+
+lemma DELETE_INTER: "pred_set.INTER (DELETE x xb) xa = DELETE (pred_set.INTER x xa) xb"
+  sorry
+
+lemma DISJOINT_DELETE_SYM: "DISJOINT (DELETE x xb) xa = DISJOINT (DELETE xa xb) x"
+  sorry
+
+consts
+  CHOICE :: "('a => bool) => 'a" 
+
+specification (CHOICE) CHOICE_DEF: "ALL x. x ~= EMPTY --> IN (CHOICE x) x"
+  sorry
+
+definition
+  REST :: "('a => bool) => 'a => bool"  where
+  "REST == %s. DELETE s (CHOICE s)"
+
+lemma REST_DEF: "REST s = DELETE s (CHOICE s)"
+  sorry
+
+lemma CHOICE_NOT_IN_REST: "~ IN (CHOICE x) (REST x)"
+  sorry
+
+lemma CHOICE_INSERT_REST: "s ~= EMPTY ==> INSERT (CHOICE s) (REST s) = s"
+  sorry
+
+lemma REST_SUBSET: "SUBSET (REST x) x"
+  sorry
+
+lemma REST_PSUBSET: "x ~= EMPTY ==> PSUBSET (REST x) x"
+  sorry
+
+definition
+  SING :: "('a => bool) => bool"  where
+  "SING == %s. EX x. s = INSERT x EMPTY"
+
+lemma SING_DEF: "SING s = (EX x. s = INSERT x EMPTY)"
+  sorry
+
+lemma SING: "SING (INSERT x EMPTY)"
+  sorry
+
+lemma IN_SING: "IN x (INSERT xa EMPTY) = (x = xa)"
+  sorry
+
+lemma NOT_SING_EMPTY: "INSERT x EMPTY ~= EMPTY"
+  sorry
+
+lemma NOT_EMPTY_SING: "EMPTY ~= INSERT x EMPTY"
+  sorry
+
+lemma EQUAL_SING: "(INSERT x EMPTY = INSERT xa EMPTY) = (x = xa)"
+  sorry
+
+lemma DISJOINT_SING_EMPTY: "DISJOINT (INSERT x EMPTY) EMPTY"
+  sorry
+
+lemma INSERT_SING_UNION: "INSERT xa x = pred_set.UNION (INSERT xa EMPTY) x"
+  sorry
+
+lemma SING_DELETE: "DELETE (INSERT x EMPTY) x = EMPTY"
+  sorry
+
+lemma DELETE_EQ_SING: "IN xa x ==> (DELETE x xa = EMPTY) = (x = INSERT xa EMPTY)"
+  sorry
+
+lemma CHOICE_SING: "CHOICE (INSERT x EMPTY) = x"
+  sorry
+
+lemma REST_SING: "REST (INSERT x EMPTY) = EMPTY"
+  sorry
+
+lemma SING_IFF_EMPTY_REST: "SING x = (x ~= EMPTY & REST x = EMPTY)"
+  sorry
+
+definition
+  IMAGE :: "('a => 'b) => ('a => bool) => 'b => bool"  where
+  "IMAGE == %f s. GSPEC (%x. (f x, IN x s))"
+
+lemma IMAGE_DEF: "IMAGE (f::'a => 'b) (s::'a => bool) = GSPEC (%x::'a. (f x, IN x s))"
+  sorry
+
+lemma IN_IMAGE: "IN (x::'b) (IMAGE (xb::'a => 'b) (xa::'a => bool)) =
+(EX xc::'a. x = xb xc & IN xc xa)"
+  sorry
+
+lemma IMAGE_IN: "IN x xa ==> IN (xb x) (IMAGE xb xa)"
+  sorry
+
+lemma IMAGE_EMPTY: "IMAGE (x::'a => 'b) EMPTY = EMPTY"
+  sorry
+
+lemma IMAGE_ID: "IMAGE (%x. x) x = x"
+  sorry
+
+lemma IMAGE_COMPOSE: "IMAGE ((x::'b => 'c) o (xa::'a => 'b)) (xb::'a => bool) =
+IMAGE x (IMAGE xa xb)"
+  sorry
+
+lemma IMAGE_INSERT: "IMAGE (x::'a => 'b) (INSERT (xa::'a) (xb::'a => bool)) =
+INSERT (x xa) (IMAGE x xb)"
+  sorry
+
+lemma IMAGE_EQ_EMPTY: "(IMAGE (x::'a => 'b) (s::'a => bool) = EMPTY) = (s = EMPTY)"
+  sorry
+
+lemma IMAGE_DELETE: "~ IN x s ==> IMAGE f (DELETE s x) = IMAGE f s"
+  sorry
+
+lemma IMAGE_UNION: "IMAGE (x::'a => 'b) (pred_set.UNION (xa::'a => bool) (xb::'a => bool)) =
+pred_set.UNION (IMAGE x xa) (IMAGE x xb)"
+  sorry
+
+lemma IMAGE_SUBSET: "SUBSET x xa ==> SUBSET (IMAGE xb x) (IMAGE xb xa)"
+  sorry
+
+lemma IMAGE_INTER: "SUBSET
+ (IMAGE (f::'a => 'b) (pred_set.INTER (s::'a => bool) (t::'a => bool)))
+ (pred_set.INTER (IMAGE f s) (IMAGE f t))"
+  sorry
+
+definition
+  INJ :: "('a => 'b) => ('a => bool) => ('b => bool) => bool"  where
+  "INJ ==
+%f s t.
+   (ALL x. IN x s --> IN (f x) t) &
+   (ALL x y. IN x s & IN y s --> f x = f y --> x = y)"
+
+lemma INJ_DEF: "INJ f s t =
+((ALL x. IN x s --> IN (f x) t) &
+ (ALL x y. IN x s & IN y s --> f x = f y --> x = y))"
+  sorry
+
+lemma INJ_ID: "INJ (%x. x) x x"
+  sorry
+
+lemma INJ_COMPOSE: "INJ x xb xc & INJ xa xc xd ==> INJ (xa o x) xb xd"
+  sorry
+
+lemma INJ_EMPTY: "All (INJ (x::'a => 'b) EMPTY) &
+(ALL xa::'a => bool. INJ x xa EMPTY = (xa = EMPTY))"
+  sorry
+
+definition
+  SURJ :: "('a => 'b) => ('a => bool) => ('b => bool) => bool"  where
+  "SURJ ==
+%f s t.
+   (ALL x. IN x s --> IN (f x) t) &
+   (ALL x. IN x t --> (EX y. IN y s & f y = x))"
+
+lemma SURJ_DEF: "SURJ f s t =
+((ALL x. IN x s --> IN (f x) t) &
+ (ALL x. IN x t --> (EX y. IN y s & f y = x)))"
+  sorry
+
+lemma SURJ_ID: "SURJ (%x. x) x x"
+  sorry
+
+lemma SURJ_COMPOSE: "SURJ x xb xc & SURJ xa xc xd ==> SURJ (xa o x) xb xd"
+  sorry
+
+lemma SURJ_EMPTY: "(ALL xa::'b => bool. SURJ (x::'a => 'b) EMPTY xa = (xa = EMPTY)) &
+(ALL xa::'a => bool. SURJ x xa EMPTY = (xa = EMPTY))"
+  sorry
+
+lemma IMAGE_SURJ: "SURJ x xa xb = (IMAGE x xa = xb)"
+  sorry
+
+definition
+  BIJ :: "('a => 'b) => ('a => bool) => ('b => bool) => bool"  where
+  "BIJ == %f s t. INJ f s t & SURJ f s t"
+
+lemma BIJ_DEF: "BIJ f s t = (INJ f s t & SURJ f s t)"
+  sorry
+
+lemma BIJ_ID: "BIJ (%x. x) x x"
+  sorry
+
+lemma BIJ_EMPTY: "(ALL xa::'b => bool. BIJ (x::'a => 'b) EMPTY xa = (xa = EMPTY)) &
+(ALL xa::'a => bool. BIJ x xa EMPTY = (xa = EMPTY))"
+  sorry
+
+lemma BIJ_COMPOSE: "BIJ x xb xc & BIJ xa xc xd ==> BIJ (xa o x) xb xd"
+  sorry
+
+consts
+  LINV :: "('a => 'b) => ('a => bool) => 'b => 'a" 
+
+specification (LINV) LINV_DEF: "ALL f s t. INJ f s t --> (ALL x. IN x s --> LINV f s (f x) = x)"
+  sorry
+
+consts
+  RINV :: "('a => 'b) => ('a => bool) => 'b => 'a" 
+
+specification (RINV) RINV_DEF: "ALL f s t. SURJ f s t --> (ALL x. IN x t --> f (RINV f s x) = x)"
+  sorry
+
+definition
+  FINITE :: "('a => bool) => bool"  where
+  "FINITE ==
+%s. ALL P. P EMPTY & (ALL s. P s --> (ALL e. P (INSERT e s))) --> P s"
+
+lemma FINITE_DEF: "FINITE s =
+(ALL P. P EMPTY & (ALL s. P s --> (ALL e. P (INSERT e s))) --> P s)"
+  sorry
+
+lemma FINITE_EMPTY: "FINITE EMPTY"
+  sorry
+
+lemma FINITE_INDUCT: "[| P EMPTY &
+   (ALL s. FINITE s & P s --> (ALL e. ~ IN e s --> P (INSERT e s)));
+   FINITE s |]
+==> P s"
+  sorry
+
+lemma FINITE_INSERT: "FINITE (INSERT x s) = FINITE s"
+  sorry
+
+lemma FINITE_DELETE: "FINITE (DELETE s x) = FINITE s"
+  sorry
+
+lemma FINITE_UNION: "FINITE (pred_set.UNION s t) = (FINITE s & FINITE t)"
+  sorry
+
+lemma INTER_FINITE: "FINITE s ==> FINITE (pred_set.INTER s t)"
+  sorry
+
+lemma SUBSET_FINITE: "[| FINITE s; SUBSET t s |] ==> FINITE t"
+  sorry
+
+lemma PSUBSET_FINITE: "[| FINITE x; PSUBSET xa x |] ==> FINITE xa"
+  sorry
+
+lemma FINITE_DIFF: "FINITE s ==> FINITE (DIFF s t)"
+  sorry
+
+lemma FINITE_SING: "FINITE (INSERT x EMPTY)"
+  sorry
+
+lemma SING_FINITE: "SING x ==> FINITE x"
+  sorry
+
+lemma IMAGE_FINITE: "FINITE s ==> FINITE (IMAGE f s)"
+  sorry
+
+consts
+  CARD :: "('a => bool) => nat" 
+
+specification (CARD) CARD_DEF: "(op &::bool => bool => bool)
+ ((op =::nat => nat => bool)
+   ((CARD::('a::type => bool) => nat) (EMPTY::'a::type => bool)) (0::nat))
+ ((All::(('a::type => bool) => bool) => bool)
+   (%s::'a::type => bool.
+       (op -->::bool => bool => bool)
+        ((FINITE::('a::type => bool) => bool) s)
+        ((All::('a::type => bool) => bool)
+          (%x::'a::type.
+              (op =::nat => nat => bool)
+               ((CARD::('a::type => bool) => nat)
+                 ((INSERT::'a::type
+                           => ('a::type => bool) => 'a::type => bool)
+                   x s))
+               ((If::bool => nat => nat => nat)
+                 ((IN::'a::type => ('a::type => bool) => bool) x s)
+                 ((CARD::('a::type => bool) => nat) s)
+                 ((Suc::nat => nat)
+                   ((CARD::('a::type => bool) => nat) s)))))))"
+  sorry
+
+lemma CARD_EMPTY: "CARD EMPTY = 0"
+  sorry
+
+lemma CARD_INSERT: "FINITE s ==> CARD (INSERT x s) = (if IN x s then CARD s else Suc (CARD s))"
+  sorry
+
+lemma CARD_EQ_0: "FINITE s ==> (CARD s = 0) = (s = EMPTY)"
+  sorry
+
+lemma CARD_DELETE: "FINITE s ==> CARD (DELETE s x) = (if IN x s then CARD s - 1 else CARD s)"
+  sorry
+
+lemma CARD_INTER_LESS_EQ: "FINITE s ==> CARD (pred_set.INTER s t) <= CARD s"
+  sorry
+
+lemma CARD_UNION: "[| FINITE s; FINITE t |]
+==> CARD (pred_set.UNION s t) + CARD (pred_set.INTER s t) = CARD s + CARD t"
+  sorry
+
+lemma CARD_SUBSET: "[| FINITE s; SUBSET t s |] ==> CARD t <= CARD s"
+  sorry
+
+lemma CARD_PSUBSET: "[| FINITE s; PSUBSET t s |] ==> CARD t < CARD s"
+  sorry
+
+lemma CARD_SING: "CARD (INSERT x EMPTY) = 1"
+  sorry
+
+lemma SING_IFF_CARD1: "SING x = (CARD x = 1 & FINITE x)"
+  sorry
+
+lemma CARD_DIFF: "[| FINITE t; FINITE s |]
+==> CARD (DIFF s t) = CARD s - CARD (pred_set.INTER s t)"
+  sorry
+
+lemma LESS_CARD_DIFF: "[| FINITE t; FINITE s; CARD t < CARD s |] ==> 0 < CARD (DIFF s t)"
+  sorry
+
+lemma FINITE_COMPLETE_INDUCTION: "[| !!x. [| !!y. PSUBSET y x ==> P y; FINITE x |] ==> P x; FINITE x |]
+==> P x"
+  sorry
+
+definition
+  INFINITE :: "('a => bool) => bool"  where
+  "INFINITE == %s. ~ FINITE s"
+
+lemma INFINITE_DEF: "INFINITE s = (~ FINITE s)"
+  sorry
+
+lemma NOT_IN_FINITE: "(op =::bool => bool => bool)
+ ((INFINITE::('a::type => bool) => bool) (pred_set.UNIV::'a::type => bool))
+ ((All::(('a::type => bool) => bool) => bool)
+   (%s::'a::type => bool.
+       (op -->::bool => bool => bool)
+        ((FINITE::('a::type => bool) => bool) s)
+        ((Ex::('a::type => bool) => bool)
+          (%x::'a::type.
+              (Not::bool => bool)
+               ((IN::'a::type => ('a::type => bool) => bool) x s)))))"
+  sorry
+
+lemma INFINITE_INHAB: "INFINITE x ==> EX xa. IN xa x"
+  sorry
+
+lemma IMAGE_11_INFINITE: "[| !!x y. f x = f y ==> x = y; INFINITE s |] ==> INFINITE (IMAGE f s)"
+  sorry
+
+lemma INFINITE_SUBSET: "[| INFINITE x; SUBSET x xa |] ==> INFINITE xa"
+  sorry
+
+lemma IN_INFINITE_NOT_FINITE: "INFINITE x & FINITE xa ==> EX xb. IN xb x & ~ IN xb xa"
+  sorry
+
+lemma INFINITE_UNIV: "(op =::bool => bool => bool)
+ ((INFINITE::('a::type => bool) => bool) (pred_set.UNIV::'a::type => bool))
+ ((Ex::(('a::type => 'a::type) => bool) => bool)
+   (%f::'a::type => 'a::type.
+       (op &::bool => bool => bool)
+        ((All::('a::type => bool) => bool)
+          (%x::'a::type.
+              (All::('a::type => bool) => bool)
+               (%y::'a::type.
+                   (op -->::bool => bool => bool)
+                    ((op =::'a::type => 'a::type => bool) (f x) (f y))
+                    ((op =::'a::type => 'a::type => bool) x y))))
+        ((Ex::('a::type => bool) => bool)
+          (%y::'a::type.
+              (All::('a::type => bool) => bool)
+               (%x::'a::type.
+                   (op ~=::'a::type => 'a::type => bool) (f x) y)))))"
+  sorry
+
+lemma FINITE_PSUBSET_INFINITE: "INFINITE x = (ALL xa. FINITE xa --> SUBSET xa x --> PSUBSET xa x)"
+  sorry
+
+lemma FINITE_PSUBSET_UNIV: "(op =::bool => bool => bool)
+ ((INFINITE::('a::type => bool) => bool) (pred_set.UNIV::'a::type => bool))
+ ((All::(('a::type => bool) => bool) => bool)
+   (%s::'a::type => bool.
+       (op -->::bool => bool => bool)
+        ((FINITE::('a::type => bool) => bool) s)
+        ((PSUBSET::('a::type => bool) => ('a::type => bool) => bool) s
+          (pred_set.UNIV::'a::type => bool))))"
+  sorry
+
+lemma INFINITE_DIFF_FINITE: "INFINITE s & FINITE t ==> DIFF s t ~= EMPTY"
+  sorry
+
+lemma FINITE_ISO_NUM: "FINITE s
+==> EX f. (ALL n m. n < CARD s & m < CARD s --> f n = f m --> n = m) &
+          s = GSPEC (%n. (f n, n < CARD s))"
+  sorry
+
+lemma FINITE_WEAK_ENUMERATE: "FINITE (x::'a => bool) =
+(EX (f::nat => 'a) b::nat. ALL e::'a. IN e x = (EX n<b. e = f n))"
+  sorry
+
+definition
+  BIGUNION :: "(('a => bool) => bool) => 'a => bool"  where
+  "BIGUNION == %P. GSPEC (%x. (x, EX p. IN p P & IN x p))"
+
+lemma BIGUNION: "BIGUNION P = GSPEC (%x. (x, EX p. IN p P & IN x p))"
+  sorry
+
+lemma IN_BIGUNION: "IN x (BIGUNION xa) = (EX s. IN x s & IN s xa)"
+  sorry
+
+lemma BIGUNION_EMPTY: "BIGUNION EMPTY = EMPTY"
+  sorry
+
+lemma BIGUNION_SING: "BIGUNION (INSERT x EMPTY) = x"
+  sorry
+
+lemma BIGUNION_UNION: "BIGUNION (pred_set.UNION x xa) = pred_set.UNION (BIGUNION x) (BIGUNION xa)"
+  sorry
+
+lemma DISJOINT_BIGUNION: "(ALL (s::('a => bool) => bool) t::'a => bool.
+    DISJOINT (BIGUNION s) t =
+    (ALL s'::'a => bool. IN s' s --> DISJOINT s' t)) &
+(ALL (x::('a => bool) => bool) xa::'a => bool.
+    DISJOINT xa (BIGUNION x) =
+    (ALL xb::'a => bool. IN xb x --> DISJOINT xa xb))"
+  sorry
+
+lemma BIGUNION_INSERT: "BIGUNION (INSERT x xa) = pred_set.UNION x (BIGUNION xa)"
+  sorry
+
+lemma BIGUNION_SUBSET: "SUBSET (BIGUNION P) X = (ALL Y. IN Y P --> SUBSET Y X)"
+  sorry
+
+lemma FINITE_BIGUNION: "FINITE x & (ALL s. IN s x --> FINITE s) ==> FINITE (BIGUNION x)"
+  sorry
+
+definition
+  BIGINTER :: "(('a => bool) => bool) => 'a => bool"  where
+  "BIGINTER == %B. GSPEC (%x. (x, ALL P. IN P B --> IN x P))"
+
+lemma BIGINTER: "BIGINTER B = GSPEC (%x. (x, ALL P. IN P B --> IN x P))"
+  sorry
+
+lemma IN_BIGINTER: "IN x (BIGINTER B) = (ALL P. IN P B --> IN x P)"
+  sorry
+
+lemma BIGINTER_INSERT: "BIGINTER (INSERT P B) = pred_set.INTER P (BIGINTER B)"
+  sorry
+
+lemma BIGINTER_EMPTY: "BIGINTER EMPTY = pred_set.UNIV"
+  sorry
+
+lemma BIGINTER_INTER: "BIGINTER (INSERT x (INSERT xa EMPTY)) = pred_set.INTER x xa"
+  sorry
+
+lemma BIGINTER_SING: "BIGINTER (INSERT x EMPTY) = x"
+  sorry
+
+lemma SUBSET_BIGINTER: "SUBSET X (BIGINTER P) = (ALL x. IN x P --> SUBSET X x)"
+  sorry
+
+lemma DISJOINT_BIGINTER: "IN xa xb & DISJOINT xa x
+==> DISJOINT x (BIGINTER xb) & DISJOINT (BIGINTER xb) x"
+  sorry
+
+definition
+  CROSS :: "('a => bool) => ('b => bool) => 'a * 'b => bool"  where
+  "CROSS == %P Q. GSPEC (%p. (p, IN (fst p) P & IN (snd p) Q))"
+
+lemma CROSS_DEF: "CROSS P Q = GSPEC (%p. (p, IN (fst p) P & IN (snd p) Q))"
+  sorry
+
+lemma IN_CROSS: "IN xb (CROSS x xa) = (IN (fst xb) x & IN (snd xb) xa)"
+  sorry
+
+lemma CROSS_EMPTY: "CROSS x EMPTY = EMPTY & CROSS EMPTY x = EMPTY"
+  sorry
+
+lemma CROSS_INSERT_LEFT: "CROSS (INSERT xb x) xa =
+pred_set.UNION (CROSS (INSERT xb EMPTY) xa) (CROSS x xa)"
+  sorry
+
+lemma CROSS_INSERT_RIGHT: "CROSS x (INSERT xb xa) =
+pred_set.UNION (CROSS x (INSERT xb EMPTY)) (CROSS x xa)"
+  sorry
+
+lemma FINITE_CROSS: "FINITE x & FINITE xa ==> FINITE (CROSS x xa)"
+  sorry
+
+lemma CROSS_SINGS: "CROSS (INSERT x EMPTY) (INSERT xa EMPTY) = INSERT (x, xa) EMPTY"
+  sorry
+
+lemma CARD_SING_CROSS: "FINITE (s::'b => bool) ==> CARD (CROSS (INSERT (x::'a) EMPTY) s) = CARD s"
+  sorry
+
+lemma CARD_CROSS: "FINITE x & FINITE xa ==> CARD (CROSS x xa) = CARD x * CARD xa"
+  sorry
+
+lemma CROSS_SUBSET: "SUBSET (CROSS xb xc) (CROSS x xa) =
+(xb = EMPTY | xc = EMPTY | SUBSET xb x & SUBSET xc xa)"
+  sorry
+
+lemma FINITE_CROSS_EQ: "FINITE (CROSS P Q) = (P = EMPTY | Q = EMPTY | FINITE P & FINITE Q)"
+  sorry
+
+definition
+  COMPL :: "('a => bool) => 'a => bool"  where
+  "COMPL == DIFF pred_set.UNIV"
+
+lemma COMPL_DEF: "COMPL P = DIFF pred_set.UNIV P"
+  sorry
+
+lemma IN_COMPL: "IN x (COMPL xa) = (~ IN x xa)"
+  sorry
+
+lemma COMPL_COMPL: "COMPL (COMPL x) = x"
+  sorry
+
+lemma COMPL_CLAUSES: "pred_set.INTER (COMPL x) x = EMPTY &
+pred_set.UNION (COMPL x) x = pred_set.UNIV"
+  sorry
+
+lemma COMPL_SPLITS: "pred_set.UNION (pred_set.INTER x xa) (pred_set.INTER (COMPL x) xa) = xa"
+  sorry
+
+lemma INTER_UNION_COMPL: "pred_set.INTER x xa = COMPL (pred_set.UNION (COMPL x) (COMPL xa))"
+  sorry
+
+lemma COMPL_EMPTY: "COMPL EMPTY = pred_set.UNIV"
+  sorry
+
+consts
+  count :: "nat => nat => bool" 
+
+defs
+  count_primdef: "count == %n. GSPEC (%m. (m, m < n))"
+
+lemma count_def: "count n = GSPEC (%m. (m, m < n))"
+  sorry
+
+lemma IN_COUNT: "IN m (count n) = (m < n)"
+  sorry
+
+lemma COUNT_ZERO: "count 0 = EMPTY"
+  sorry
+
+lemma COUNT_SUC: "count (Suc n) = INSERT n (count n)"
+  sorry
+
+lemma FINITE_COUNT: "FINITE (count n)"
+  sorry
+
+lemma CARD_COUNT: "CARD (count n) = n"
+  sorry
+
+definition
+  ITSET_tupled :: "('a => 'b => 'b) => ('a => bool) * 'b => 'b"  where
+  "ITSET_tupled ==
+%f. WFREC
+     (SOME R.
+         WF R &
+         (ALL b s.
+             FINITE s & s ~= EMPTY --> R (REST s, f (CHOICE s) b) (s, b)))
+     (%ITSET_tupled (v, v1).
+         if FINITE v
+         then if v = EMPTY then v1
+              else ITSET_tupled (REST v, f (CHOICE v) v1)
+         else ARB)"
+
+lemma ITSET_tupled_primitive_def: "ITSET_tupled f =
+WFREC
+ (SOME R.
+     WF R &
+     (ALL b s. FINITE s & s ~= EMPTY --> R (REST s, f (CHOICE s) b) (s, b)))
+ (%ITSET_tupled (v, v1).
+     if FINITE v
+     then if v = EMPTY then v1 else ITSET_tupled (REST v, f (CHOICE v) v1)
+     else ARB)"
+  sorry
+
+definition
+  ITSET :: "('a => 'b => 'b) => ('a => bool) => 'b => 'b"  where
+  "ITSET == %f x x1. ITSET_tupled f (x, x1)"
+
+lemma ITSET_curried_def: "ITSET (f::'a => 'b => 'b) (x::'a => bool) (x1::'b) = ITSET_tupled f (x, x1)"
+  sorry
+
+lemma ITSET_IND: "(!!(s::'a => bool) b::'b.
+    (FINITE s & s ~= EMPTY
+     ==> (P::('a => bool) => 'b => bool) (REST s)
+          ((f::'a => 'b => 'b) (CHOICE s) b))
+    ==> P s b)
+==> P (v::'a => bool) (x::'b)"
+  sorry
+
+lemma ITSET_THM: "FINITE s
+==> ITSET f s b =
+    (if s = EMPTY then b else ITSET f (REST s) (f (CHOICE s) b))"
+  sorry
+
+lemma ITSET_EMPTY: "ITSET (x::'a => 'b => 'b) EMPTY (xa::'b) = xa"
+  sorry
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" operator
+
+definition
+  ASSOC :: "('a => 'a => 'a) => bool"  where
+  "ASSOC == %f. ALL x y z. f x (f y z) = f (f x y) z"
+
+lemma ASSOC_DEF: "ASSOC f = (ALL x y z. f x (f y z) = f (f x y) z)"
+  sorry
+
+definition
+  COMM :: "('a => 'a => 'b) => bool"  where
+  "COMM == %f. ALL x y. f x y = f y x"
+
+lemma COMM_DEF: "COMM f = (ALL x y. f x y = f y x)"
+  sorry
+
+definition
+  FCOMM :: "('a => 'b => 'a) => ('c => 'a => 'a) => bool"  where
+  "FCOMM == %f g. ALL x y z. g x (f y z) = f (g x y) z"
+
+lemma FCOMM_DEF: "FCOMM f g = (ALL x y z. g x (f y z) = f (g x y) z)"
+  sorry
+
+definition
+  RIGHT_ID :: "('a => 'b => 'a) => 'b => bool"  where
+  "RIGHT_ID == %f e. ALL x. f x e = x"
+
+lemma RIGHT_ID_DEF: "RIGHT_ID f e = (ALL x. f x e = x)"
+  sorry
+
+definition
+  LEFT_ID :: "('a => 'b => 'b) => 'a => bool"  where
+  "LEFT_ID == %f e. ALL x. f e x = x"
+
+lemma LEFT_ID_DEF: "LEFT_ID f e = (ALL x. f e x = x)"
+  sorry
+
+definition
+  MONOID :: "('a => 'a => 'a) => 'a => bool"  where
+  "MONOID == %f e. ASSOC f & RIGHT_ID f e & LEFT_ID f e"
+
+lemma MONOID_DEF: "MONOID f e = (ASSOC f & RIGHT_ID f e & LEFT_ID f e)"
+  sorry
+
+lemma ASSOC_CONJ: "ASSOC op &"
+  sorry
+
+lemma ASSOC_DISJ: "ASSOC op |"
+  sorry
+
+lemma FCOMM_ASSOC: "FCOMM x x = ASSOC x"
+  sorry
+
+lemma MONOID_CONJ_T: "MONOID op & True"
+  sorry
+
+lemma MONOID_DISJ_F: "MONOID op | False"
+  sorry
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" rich_list
+
+consts
+  SNOC :: "'a => 'a list => 'a list" 
+
+specification (SNOC) SNOC: "(ALL x::'a. SNOC x [] = [x]) &
+(ALL (x::'a) (x'::'a) l::'a list. SNOC x (x' # l) = x' # SNOC x l)"
+  sorry
+
+consts
+  SCANL :: "('b => 'a => 'b) => 'b => 'a list => 'b list" 
+
+specification (SCANL) SCANL: "(ALL (f::'b => 'a => 'b) e::'b. SCANL f e [] = [e]) &
+(ALL (f::'b => 'a => 'b) (e::'b) (x::'a) l::'a list.
+    SCANL f e (x # l) = e # SCANL f (f e x) l)"
+  sorry
+
+consts
+  SCANR :: "('a => 'b => 'b) => 'b => 'a list => 'b list" 
+
+specification (SCANR) SCANR: "(ALL (f::'a => 'b => 'b) e::'b. SCANR f e [] = [e]) &
+(ALL (f::'a => 'b => 'b) (e::'b) (x::'a) l::'a list.
+    SCANR f e (x # l) = f x (hd (SCANR f e l)) # SCANR f e l)"
+  sorry
+
+lemma IS_EL_DEF: "List.member l x = list_ex (op = x) l"
+  sorry
+
+definition
+  AND_EL :: "bool list => bool"  where
+  "AND_EL == list_all I"
+
+lemma AND_EL_DEF: "AND_EL = list_all I"
+  sorry
+
+definition
+  OR_EL :: "bool list => bool"  where
+  "OR_EL == list_ex I"
+
+lemma OR_EL_DEF: "OR_EL = list_ex I"
+  sorry
+
+consts
+  FIRSTN :: "nat => 'a list => 'a list" 
+
+specification (FIRSTN) FIRSTN: "(ALL l::'a list. FIRSTN (0::nat) l = []) &
+(ALL (n::nat) (x::'a) l::'a list. FIRSTN (Suc n) (x # l) = x # FIRSTN n l)"
+  sorry
+
+consts
+  BUTFIRSTN :: "nat => 'a list => 'a list" 
+
+specification (BUTFIRSTN) BUTFIRSTN: "(ALL l::'a list. BUTFIRSTN (0::nat) l = l) &
+(ALL (n::nat) (x::'a) l::'a list. BUTFIRSTN (Suc n) (x # l) = BUTFIRSTN n l)"
+  sorry
+
+consts
+  SEG :: "nat => nat => 'a list => 'a list" 
+
+specification (SEG) SEG: "(ALL (k::nat) l::'a list. SEG (0::nat) k l = []) &
+(ALL (m::nat) (x::'a) l::'a list.
+    SEG (Suc m) (0::nat) (x # l) = x # SEG m (0::nat) l) &
+(ALL (m::nat) (k::nat) (x::'a) l::'a list.
+    SEG (Suc m) (Suc k) (x # l) = SEG (Suc m) k l)"
+  sorry
+
+lemma LAST: "last (SNOC x l) = x"
+  sorry
+
+lemma BUTLAST: "butlast (SNOC x l) = l"
+  sorry
+
+consts
+  LASTN :: "nat => 'a list => 'a list" 
+
+specification (LASTN) LASTN: "(ALL l::'a list. LASTN (0::nat) l = []) &
+(ALL (n::nat) (x::'a) l::'a list.
+    LASTN (Suc n) (SNOC x l) = SNOC x (LASTN n l))"
+  sorry
+
+consts
+  BUTLASTN :: "nat => 'a list => 'a list" 
+
+specification (BUTLASTN) BUTLASTN: "(ALL l::'a list. BUTLASTN (0::nat) l = l) &
+(ALL (n::nat) (x::'a) l::'a list.
+    BUTLASTN (Suc n) (SNOC x l) = BUTLASTN n l)"
+  sorry
+
+lemma EL: "(ALL x::'a list. EL (0::nat) x = hd x) &
+(ALL (x::nat) xa::'a list. EL (Suc x) xa = EL x (tl xa))"
+  sorry
+
+consts
+  ELL :: "nat => 'a list => 'a" 
+
+specification (ELL) ELL: "(ALL l::'a list. ELL (0::nat) l = last l) &
+(ALL (n::nat) l::'a list. ELL (Suc n) l = ELL n (butlast l))"
+  sorry
+
+consts
+  IS_PREFIX :: "'a list => 'a list => bool" 
+
+specification (IS_PREFIX) IS_PREFIX: "(ALL l::'a list. IS_PREFIX l [] = True) &
+(ALL (x::'a) l::'a list. IS_PREFIX [] (x # l) = False) &
+(ALL (x1::'a) (l1::'a list) (x2::'a) l2::'a list.
+    IS_PREFIX (x1 # l1) (x2 # l2) = (x1 = x2 & IS_PREFIX l1 l2))"
+  sorry
+
+lemma SNOC_APPEND: "SNOC x l = l @ [x]"
+  sorry
+
+lemma REVERSE: "rev [] = [] & (ALL (x::'a) xa::'a list. rev (x # xa) = SNOC x (rev xa))"
+  sorry
+
+lemma REVERSE_SNOC: "rev (SNOC x l) = x # rev l"
+  sorry
+
+lemma SNOC_Axiom: "EX x. x [] = e & (ALL xa l. x (SNOC xa l) = f xa l (x l))"
+  sorry
+
+consts
+  IS_SUFFIX :: "'a list => 'a list => bool" 
+
+specification (IS_SUFFIX) IS_SUFFIX: "(ALL l::'a list. IS_SUFFIX l [] = True) &
+(ALL (x::'a) l::'a list. IS_SUFFIX [] (SNOC x l) = False) &
+(ALL (x1::'a) (l1::'a list) (x2::'a) l2::'a list.
+    IS_SUFFIX (SNOC x1 l1) (SNOC x2 l2) = (x1 = x2 & IS_SUFFIX l1 l2))"
+  sorry
+
+consts
+  IS_SUBLIST :: "'a list => 'a list => bool" 
+
+specification (IS_SUBLIST) IS_SUBLIST: "(ALL l::'a list. IS_SUBLIST l [] = True) &
+(ALL (x::'a) l::'a list. IS_SUBLIST [] (x # l) = False) &
+(ALL (x1::'a) (l1::'a list) (x2::'a) l2::'a list.
+    IS_SUBLIST (x1 # l1) (x2 # l2) =
+    (x1 = x2 & IS_PREFIX l1 l2 | IS_SUBLIST l1 (x2 # l2)))"
+  sorry
+
+consts
+  SPLITP :: "('a => bool) => 'a list => 'a list * 'a list" 
+
+specification (SPLITP) SPLITP: "(ALL P::'a => bool. SPLITP P [] = ([], [])) &
+(ALL (P::'a => bool) (x::'a) l::'a list.
+    SPLITP P (x # l) =
+    (if P x then ([], x # l) else (x # fst (SPLITP P l), snd (SPLITP P l))))"
+  sorry
+
+definition
+  PREFIX :: "('a => bool) => 'a list => 'a list"  where
+  "PREFIX == %P l. fst (SPLITP (Not o P) l)"
+
+lemma PREFIX_DEF: "PREFIX P l = fst (SPLITP (Not o P) l)"
+  sorry
+
+definition
+  SUFFIX :: "('a => bool) => 'a list => 'a list"  where
+  "SUFFIX == %P. foldl (%l' x. if P x then SNOC x l' else []) []"
+
+lemma SUFFIX_DEF: "SUFFIX P l = foldl (%l' x. if P x then SNOC x l' else []) [] l"
+  sorry
+
+definition
+  UNZIP_FST :: "('a * 'b) list => 'a list"  where
+  "UNZIP_FST == %l. fst (unzip l)"
+
+lemma UNZIP_FST_DEF: "UNZIP_FST l = fst (unzip l)"
+  sorry
+
+definition
+  UNZIP_SND :: "('a * 'b) list => 'b list"  where
+  "UNZIP_SND == %l. snd (unzip l)"
+
+lemma UNZIP_SND_DEF: "UNZIP_SND (l::('a * 'b) list) = snd (unzip l)"
+  sorry
+
+consts
+  GENLIST :: "(nat => 'a) => nat => 'a list" 
+
+specification (GENLIST) GENLIST: "(ALL f::nat => 'a. GENLIST f (0::nat) = []) &
+(ALL (f::nat => 'a) n::nat. GENLIST f (Suc n) = SNOC (f n) (GENLIST f n))"
+  sorry
+
+consts
+  REPLICATE :: "nat => 'a => 'a list" 
+
+specification (REPLICATE) REPLICATE: "(ALL x::'a. REPLICATE (0::nat) x = []) &
+(ALL (n::nat) x::'a. REPLICATE (Suc n) x = x # REPLICATE n x)"
+  sorry
+
+lemma LENGTH_MAP2: "length l1 = length l2
+==> length (map2 f l1 l2) = length l1 & length (map2 f l1 l2) = length l2"
+  sorry
+
+lemma LENGTH_EQ: "x = y ==> length x = length y"
+  sorry
+
+lemma LENGTH_NOT_NULL: "(0 < length l) = (~ List.null l)"
+  sorry
+
+lemma SNOC_INDUCT: "P [] & (ALL l. P l --> (ALL x. P (SNOC x l))) ==> P x"
+  sorry
+
+lemma SNOC_CASES: "x' = [] | (EX x l. x' = SNOC x l)"
+  sorry
+
+lemma LENGTH_SNOC: "length (SNOC x l) = Suc (length l)"
+  sorry
+
+lemma NOT_NIL_SNOC: "[] ~= SNOC x xa"
+  sorry
+
+lemma NOT_SNOC_NIL: "SNOC x xa ~= []"
+  sorry
+
+lemma SNOC_11: "(SNOC x l = SNOC x' l') = (x = x' & l = l')"
+  sorry
+
+lemma SNOC_EQ_LENGTH_EQ: "SNOC x1 l1 = SNOC x2 l2 ==> length l1 = length l2"
+  sorry
+
+lemma SNOC_REVERSE_CONS: "SNOC x xa = rev (x # rev xa)"
+  sorry
+
+lemma MAP_SNOC: "map (x::'a => 'b) (SNOC (xa::'a) (xb::'a list)) = SNOC (x xa) (map x xb)"
+  sorry
+
+lemma FOLDR_SNOC: "foldr (f::'a => 'b => 'b) (SNOC (x::'a) (l::'a list)) (e::'b) =
+foldr f l (f x e)"
+  sorry
+
+lemma FOLDL_SNOC: "foldl (f::'b => 'a => 'b) (e::'b) (SNOC (x::'a) (l::'a list)) =
+f (foldl f e l) x"
+  sorry
+
+lemma FOLDR_FOLDL: "MONOID f e ==> foldr f l e = foldl f e l"
+  sorry
+
+lemma LENGTH_FOLDR: "length l = foldr (%x. Suc) l 0"
+  sorry
+
+lemma LENGTH_FOLDL: "length l = foldl (%l' x. Suc l') 0 l"
+  sorry
+
+lemma MAP_FOLDR: "map (f::'a => 'b) (l::'a list) = foldr (%x::'a. op # (f x)) l []"
+  sorry
+
+lemma MAP_FOLDL: "map (f::'a => 'b) (l::'a list) =
+foldl (%(l'::'b list) x::'a. SNOC (f x) l') [] l"
+  sorry
+
+lemma FILTER_FOLDR: "filter P l = foldr (%x l'. if P x then x # l' else l') l []"
+  sorry
+
+lemma FILTER_SNOC: "filter P (SNOC x l) = (if P x then SNOC x (filter P l) else filter P l)"
+  sorry
+
+lemma FILTER_FOLDL: "filter P l = foldl (%l' x. if P x then SNOC x l' else l') [] l"
+  sorry
+
+lemma FILTER_COMM: "filter f1 (filter f2 l) = filter f2 (filter f1 l)"
+  sorry
+
+lemma FILTER_IDEM: "filter f (filter f l) = filter f l"
+  sorry
+
+lemma LENGTH_SEG: "n + k <= length l ==> length (SEG n k l) = n"
+  sorry
+
+lemma APPEND_NIL: "(ALL l::'a list. l @ [] = l) & (ALL x::'a list. [] @ x = x)"
+  sorry
+
+lemma APPEND_SNOC: "l1 @ SNOC x l2 = SNOC x (l1 @ l2)"
+  sorry
+
+lemma APPEND_FOLDR: "l1 @ l2 = foldr op # l1 l2"
+  sorry
+
+lemma APPEND_FOLDL: "l1 @ l2 = foldl (%l' x. SNOC x l') l1 l2"
+  sorry
+
+lemma CONS_APPEND: "x # l = [x] @ l"
+  sorry
+
+lemma ASSOC_APPEND: "ASSOC op @"
+  sorry
+
+lemma MONOID_APPEND_NIL: "MONOID op @ []"
+  sorry
+
+lemma APPEND_LENGTH_EQ: "[| length l1 = length l1'; length l2 = length l2' |]
+==> (l1 @ l2 = l1' @ l2') = (l1 = l1' & l2 = l2')"
+  sorry
+
+lemma FLAT_SNOC: "concat (SNOC x l) = concat l @ x"
+  sorry
+
+lemma FLAT_FOLDR: "concat l = foldr op @ l []"
+  sorry
+
+lemma LENGTH_FLAT: "length (concat l) = Compatibility.sum (map length l)"
+  sorry
+
+lemma REVERSE_FOLDR: "rev l = foldr SNOC l []"
+  sorry
+
+lemma ALL_EL_SNOC: "list_all P (SNOC x l) = (list_all P l & P x)"
+  sorry
+
+lemma ALL_EL_MAP: "list_all (P::'b => bool) (map (f::'a => 'b) (l::'a list)) =
+list_all (P o f) l"
+  sorry
+
+lemma SOME_EL_SNOC: "list_ex P (SNOC x l) = (P x | list_ex P l)"
+  sorry
+
+lemma IS_EL_SNOC: "List.member (SNOC x l) y = (y = x | List.member l y)"
+  sorry
+
+lemma SUM_SNOC: "Compatibility.sum (SNOC x l) = Compatibility.sum l + x"
+  sorry
+
+lemma SUM_FOLDL: "Compatibility.sum l = foldl op + 0 l"
+  sorry
+
+lemma IS_PREFIX_APPEND: "IS_PREFIX l1 l2 = (EX l. l1 = l2 @ l)"
+  sorry
+
+lemma IS_SUFFIX_APPEND: "IS_SUFFIX l1 l2 = (EX l. l1 = l @ l2)"
+  sorry
+
+lemma IS_SUBLIST_APPEND: "IS_SUBLIST l1 l2 = (EX l l'. l1 = l @ l2 @ l')"
+  sorry
+
+lemma IS_PREFIX_IS_SUBLIST: "IS_PREFIX l1 l2 ==> IS_SUBLIST l1 l2"
+  sorry
+
+lemma IS_SUFFIX_IS_SUBLIST: "IS_SUFFIX l1 l2 ==> IS_SUBLIST l1 l2"
+  sorry
+
+lemma IS_PREFIX_REVERSE: "IS_PREFIX (rev l1) (rev l2) = IS_SUFFIX l1 l2"
+  sorry
+
+lemma IS_SUFFIX_REVERSE: "IS_SUFFIX (rev l1) (rev l2) = IS_PREFIX l1 l2"
+  sorry
+
+lemma IS_SUBLIST_REVERSE: "IS_SUBLIST (rev l1) (rev l2) = IS_SUBLIST l1 l2"
+  sorry
+
+lemma PREFIX_FOLDR: "PREFIX P x = foldr (%x l'. if P x then x # l' else []) x []"
+  sorry
+
+lemma PREFIX: "(ALL x::'a => bool. PREFIX x [] = []) &
+(ALL (x::'a => bool) (xa::'a) xb::'a list.
+    PREFIX x (xa # xb) = (if x xa then xa # PREFIX x xb else []))"
+  sorry
+
+lemma IS_PREFIX_PREFIX: "IS_PREFIX l (PREFIX P l)"
+  sorry
+
+lemma LENGTH_SCANL: "length (SCANL (f::'b => 'a => 'b) (e::'b) (l::'a list)) = Suc (length l)"
+  sorry
+
+lemma LENGTH_SCANR: "length (SCANR (f::'a => 'b => 'b) (e::'b) (l::'a list)) = Suc (length l)"
+  sorry
+
+lemma COMM_MONOID_FOLDL: "[| COMM x; MONOID x xa |] ==> foldl x e l = x e (foldl x xa l)"
+  sorry
+
+lemma COMM_MONOID_FOLDR: "[| COMM x; MONOID x xa |] ==> foldr x l e = x e (foldr x l xa)"
+  sorry
+
+lemma FCOMM_FOLDR_APPEND: "[| FCOMM x xa; LEFT_ID x xb |]
+==> foldr xa (l1 @ l2) xb = x (foldr xa l1 xb) (foldr xa l2 xb)"
+  sorry
+
+lemma FCOMM_FOLDL_APPEND: "[| FCOMM x xa; RIGHT_ID xa xb |]
+==> foldl x xb (l1 @ l2) = xa (foldl x xb l1) (foldl x xb l2)"
+  sorry
+
+lemma FOLDL_SINGLE: "foldl x xa [xb] = x xa xb"
+  sorry
+
+lemma FOLDR_SINGLE: "foldr (x::'a => 'b => 'b) [xb::'a] (xa::'b) = x xb xa"
+  sorry
+
+lemma FOLDR_CONS_NIL: "foldr op # l [] = l"
+  sorry
+
+lemma FOLDL_SNOC_NIL: "foldl (%xs x. SNOC x xs) [] l = l"
+  sorry
+
+lemma FOLDR_REVERSE: "foldr (x::'a => 'b => 'b) (rev (xb::'a list)) (xa::'b) =
+foldl (%(xa::'b) y::'a. x y xa) xa xb"
+  sorry
+
+lemma FOLDL_REVERSE: "foldl x xa (rev xb) = foldr (%xa y. x y xa) xb xa"
+  sorry
+
+lemma FOLDR_MAP: "foldr (f::'a => 'a => 'a) (map (g::'b => 'a) (l::'b list)) (e::'a) =
+foldr (%x::'b. f (g x)) l e"
+  sorry
+
+lemma ALL_EL_FOLDR: "list_all P l = foldr (%x. op & (P x)) l True"
+  sorry
+
+lemma ALL_EL_FOLDL: "list_all P l = foldl (%l' x. l' & P x) True l"
+  sorry
+
+lemma SOME_EL_FOLDR: "list_ex P l = foldr (%x. op | (P x)) l False"
+  sorry
+
+lemma SOME_EL_FOLDL: "list_ex P l = foldl (%l' x. l' | P x) False l"
+  sorry
+
+lemma ALL_EL_FOLDR_MAP: "list_all x xa = foldr op & (map x xa) True"
+  sorry
+
+lemma ALL_EL_FOLDL_MAP: "list_all x xa = foldl op & True (map x xa)"
+  sorry
+
+lemma SOME_EL_FOLDR_MAP: "list_ex x xa = foldr op | (map x xa) False"
+  sorry
+
+lemma SOME_EL_FOLDL_MAP: "list_ex x xa = foldl op | False (map x xa)"
+  sorry
+
+lemma FOLDR_FILTER: "foldr (f::'a => 'a => 'a) (filter (P::'a => bool) (l::'a list)) (e::'a) =
+foldr (%(x::'a) y::'a. if P x then f x y else y) l e"
+  sorry
+
+lemma FOLDL_FILTER: "foldl (f::'a => 'a => 'a) (e::'a) (filter (P::'a => bool) (l::'a list)) =
+foldl (%(x::'a) y::'a. if P y then f x y else x) e l"
+  sorry
+
+lemma ASSOC_FOLDR_FLAT: "[| ASSOC f; LEFT_ID f e |]
+==> foldr f (concat l) e = foldr f (map (FOLDR f e) l) e"
+  sorry
+
+lemma ASSOC_FOLDL_FLAT: "[| ASSOC f; RIGHT_ID f e |]
+==> foldl f e (concat l) = foldl f e (map (foldl f e) l)"
+  sorry
+
+lemma SOME_EL_MAP: "list_ex (P::'b => bool) (map (f::'a => 'b) (l::'a list)) = list_ex (P o f) l"
+  sorry
+
+lemma SOME_EL_DISJ: "list_ex (%x. P x | Q x) l = (list_ex P l | list_ex Q l)"
+  sorry
+
+lemma IS_EL_FOLDR: "List.member xa x = foldr (%xa. op | (x = xa)) xa False"
+  sorry
+
+lemma IS_EL_FOLDL: "List.member xa x = foldl (%l' xa. l' | x = xa) False xa"
+  sorry
+
+lemma NULL_FOLDR: "List.null l = foldr (%x l'. False) l True"
+  sorry
+
+lemma NULL_FOLDL: "List.null l = foldl (%x l'. False) True l"
+  sorry
+
+lemma SEG_LENGTH_ID: "SEG (length l) 0 l = l"
+  sorry
+
+lemma SEG_SUC_CONS: "SEG m (Suc n) (x # l) = SEG m n l"
+  sorry
+
+lemma SEG_0_SNOC: "m <= length l ==> SEG m 0 (SNOC x l) = SEG m 0 l"
+  sorry
+
+lemma BUTLASTN_SEG: "n <= length l ==> BUTLASTN n l = SEG (length l - n) 0 l"
+  sorry
+
+lemma LASTN_CONS: "n <= length l ==> LASTN n (x # l) = LASTN n l"
+  sorry
+
+lemma LENGTH_LASTN: "n <= length l ==> length (LASTN n l) = n"
+  sorry
+
+lemma LASTN_LENGTH_ID: "LASTN (length l) l = l"
+  sorry
+
+lemma LASTN_LASTN: "[| m <= length l; n <= m |] ==> LASTN n (LASTN m l) = LASTN n l"
+  sorry
+
+lemma FIRSTN_LENGTH_ID: "FIRSTN (length l) l = l"
+  sorry
+
+lemma FIRSTN_SNOC: "n <= length l ==> FIRSTN n (SNOC x l) = FIRSTN n l"
+  sorry
+
+lemma BUTLASTN_LENGTH_NIL: "BUTLASTN (length l) l = []"
+  sorry
+
+lemma BUTLASTN_SUC_BUTLAST: "n < length l ==> BUTLASTN (Suc n) l = BUTLASTN n (butlast l)"
+  sorry
+
+lemma BUTLASTN_BUTLAST: "n < length l ==> BUTLASTN n (butlast l) = butlast (BUTLASTN n l)"
+  sorry
+
+lemma LENGTH_BUTLASTN: "n <= length l ==> length (BUTLASTN n l) = length l - n"
+  sorry
+
+lemma BUTLASTN_BUTLASTN: "n + m <= length l ==> BUTLASTN n (BUTLASTN m l) = BUTLASTN (n + m) l"
+  sorry
+
+lemma APPEND_BUTLASTN_LASTN: "n <= length l ==> BUTLASTN n l @ LASTN n l = l"
+  sorry
+
+lemma APPEND_FIRSTN_LASTN: "m + n = length l ==> FIRSTN n l @ LASTN m l = l"
+  sorry
+
+lemma BUTLASTN_APPEND2: "n <= length l2 ==> BUTLASTN n (l1 @ l2) = l1 @ BUTLASTN n l2"
+  sorry
+
+lemma BUTLASTN_LENGTH_APPEND: "BUTLASTN (length l2) (l1 @ l2) = l1"
+  sorry
+
+lemma LASTN_LENGTH_APPEND: "LASTN (length l2) (l1 @ l2) = l2"
+  sorry
+
+lemma BUTLASTN_CONS: "n <= length l ==> BUTLASTN n (x # l) = x # BUTLASTN n l"
+  sorry
+
+lemma BUTLASTN_LENGTH_CONS: "BUTLASTN (length l) (x # l) = [x]"
+  sorry
+
+lemma LAST_LASTN_LAST: "[| n <= length l; 0 < n |] ==> last (LASTN n l) = last l"
+  sorry
+
+lemma BUTLASTN_LASTN_NIL: "n <= length l ==> BUTLASTN n (LASTN n l) = []"
+  sorry
+
+lemma LASTN_BUTLASTN: "n + m <= length l ==> LASTN n (BUTLASTN m l) = BUTLASTN m (LASTN (n + m) l)"
+  sorry
+
+lemma BUTLASTN_LASTN: "m <= n & n <= length l
+==> BUTLASTN m (LASTN n l) = LASTN (n - m) (BUTLASTN m l)"
+  sorry
+
+lemma LASTN_1: "l ~= [] ==> LASTN 1 l = [last l]"
+  sorry
+
+lemma BUTLASTN_1: "l ~= [] ==> BUTLASTN 1 l = butlast l"
+  sorry
+
+lemma BUTLASTN_APPEND1: "length l2 <= n ==> BUTLASTN n (l1 @ l2) = BUTLASTN (n - length l2) l1"
+  sorry
+
+lemma LASTN_APPEND2: "n <= length l2 ==> LASTN n (l1 @ l2) = LASTN n l2"
+  sorry
+
+lemma LASTN_APPEND1: "length l2 <= n ==> LASTN n (l1 @ l2) = LASTN (n - length l2) l1 @ l2"
+  sorry
+
+lemma LASTN_MAP: "n <= length l ==> LASTN n (map f l) = map f (LASTN n l)"
+  sorry
+
+lemma BUTLASTN_MAP: "n <= length l ==> BUTLASTN n (map f l) = map f (BUTLASTN n l)"
+  sorry
+
+lemma ALL_EL_LASTN: "[| list_all P l; m <= length l |] ==> list_all P (LASTN m l)"
+  sorry
+
+lemma ALL_EL_BUTLASTN: "[| list_all P l; m <= length l |] ==> list_all P (BUTLASTN m l)"
+  sorry
+
+lemma LENGTH_FIRSTN: "n <= length l ==> length (FIRSTN n l) = n"
+  sorry
+
+lemma FIRSTN_FIRSTN: "[| m <= length l; n <= m |] ==> FIRSTN n (FIRSTN m l) = FIRSTN n l"
+  sorry
+
+lemma LENGTH_BUTFIRSTN: "n <= length l ==> length (BUTFIRSTN n l) = length l - n"
+  sorry
+
+lemma BUTFIRSTN_LENGTH_NIL: "BUTFIRSTN (length l) l = []"
+  sorry
+
+lemma BUTFIRSTN_APPEND1: "n <= length l1 ==> BUTFIRSTN n (l1 @ l2) = BUTFIRSTN n l1 @ l2"
+  sorry
+
+lemma BUTFIRSTN_APPEND2: "length l1 <= n ==> BUTFIRSTN n (l1 @ l2) = BUTFIRSTN (n - length l1) l2"
+  sorry
+
+lemma BUTFIRSTN_BUTFIRSTN: "n + m <= length l ==> BUTFIRSTN n (BUTFIRSTN m l) = BUTFIRSTN (n + m) l"
+  sorry
+
+lemma APPEND_FIRSTN_BUTFIRSTN: "n <= length l ==> FIRSTN n l @ BUTFIRSTN n l = l"
+  sorry
+
+lemma LASTN_SEG: "n <= length l ==> LASTN n l = SEG n (length l - n) l"
+  sorry
+
+lemma FIRSTN_SEG: "n <= length l ==> FIRSTN n l = SEG n 0 l"
+  sorry
+
+lemma BUTFIRSTN_SEG: "n <= length l ==> BUTFIRSTN n l = SEG (length l - n) n l"
+  sorry
+
+lemma BUTFIRSTN_SNOC: "n <= length l ==> BUTFIRSTN n (SNOC x l) = SNOC x (BUTFIRSTN n l)"
+  sorry
+
+lemma APPEND_BUTLASTN_BUTFIRSTN: "m + n = length l ==> BUTLASTN m l @ BUTFIRSTN n l = l"
+  sorry
+
+lemma SEG_SEG: "n1 + m1 <= length l & n2 + m2 <= n1
+==> SEG n2 m2 (SEG n1 m1 l) = SEG n2 (m1 + m2) l"
+  sorry
+
+lemma SEG_APPEND1: "n + m <= length l1 ==> SEG n m (l1 @ l2) = SEG n m l1"
+  sorry
+
+lemma SEG_APPEND2: "length l1 <= m & n <= length l2
+==> SEG n m (l1 @ l2) = SEG n (m - length l1) l2"
+  sorry
+
+lemma SEG_FIRSTN_BUTFISTN: "n + m <= length l ==> SEG n m l = FIRSTN n (BUTFIRSTN m l)"
+  sorry
+
+lemma SEG_APPEND: "m < length l1 & length l1 <= n + m & n + m <= length l1 + length l2
+==> SEG n m (l1 @ l2) =
+    SEG (length l1 - m) m l1 @ SEG (n + m - length l1) 0 l2"
+  sorry
+
+lemma SEG_LENGTH_SNOC: "SEG 1 (length x) (SNOC xa x) = [xa]"
+  sorry
+
+lemma SEG_SNOC: "n + m <= length l ==> SEG n m (SNOC x l) = SEG n m l"
+  sorry
+
+lemma ELL_SEG: "n < length l ==> ELL n l = hd (SEG 1 (PRE (length l - n)) l)"
+  sorry
+
+lemma SNOC_FOLDR: "SNOC x l = foldr op # l [x]"
+  sorry
+
+lemma IS_EL_FOLDR_MAP: "List.member xa x = foldr op | (map (op = x) xa) False"
+  sorry
+
+lemma IS_EL_FOLDL_MAP: "List.member xa x = foldl op | False (map (op = x) xa)"
+  sorry
+
+lemma FILTER_FILTER: "filter P (filter Q l) = [x<-l. P x & Q x]"
+  sorry
+
+lemma FCOMM_FOLDR_FLAT: "[| FCOMM g f; LEFT_ID g e |]
+==> foldr f (concat l) e = foldr g (map (FOLDR f e) l) e"
+  sorry
+
+lemma FCOMM_FOLDL_FLAT: "[| FCOMM f g; RIGHT_ID g e |]
+==> foldl f e (concat l) = foldl g e (map (foldl f e) l)"
+  sorry
+
+lemma FOLDR_MAP_REVERSE: "(!!(a::'a) (b::'a) c::'a. (f::'a => 'a => 'a) a (f b c) = f b (f a c))
+==> foldr f (map (g::'b => 'a) (rev (l::'b list))) (e::'a) =
+    foldr f (map g l) e"
+  sorry
+
+lemma FOLDR_FILTER_REVERSE: "(!!(a::'a) (b::'a) c::'a. (f::'a => 'a => 'a) a (f b c) = f b (f a c))
+==> foldr f (filter (P::'a => bool) (rev (l::'a list))) (e::'a) =
+    foldr f (filter P l) e"
+  sorry
+
+lemma COMM_ASSOC_FOLDR_REVERSE: "[| COMM f; ASSOC f |] ==> foldr f (rev l) e = foldr f l e"
+  sorry
+
+lemma COMM_ASSOC_FOLDL_REVERSE: "[| COMM f; ASSOC f |] ==> foldl f e (rev l) = foldl f e l"
+  sorry
+
+lemma ELL_LAST: "~ List.null l ==> ELL 0 l = last l"
+  sorry
+
+lemma ELL_0_SNOC: "ELL 0 (SNOC x l) = x"
+  sorry
+
+lemma ELL_SNOC: "0 < n ==> ELL n (SNOC x l) = ELL (PRE n) l"
+  sorry
+
+lemma ELL_SUC_SNOC: "ELL (Suc n) (SNOC x xa) = ELL n xa"
+  sorry
+
+lemma ELL_CONS: "n < length l ==> ELL n (x # l) = ELL n l"
+  sorry
+
+lemma ELL_LENGTH_CONS: "ELL (length l) (x # l) = x"
+  sorry
+
+lemma ELL_LENGTH_SNOC: "ELL (length l) (SNOC x l) = (if List.null l then x else hd l)"
+  sorry
+
+lemma ELL_APPEND2: "n < length l2 ==> ELL n (l1 @ l2) = ELL n l2"
+  sorry
+
+lemma ELL_APPEND1: "length l2 <= n ==> ELL n (l1 @ l2) = ELL (n - length l2) l1"
+  sorry
+
+lemma ELL_PRE_LENGTH: "l ~= [] ==> ELL (PRE (length l)) l = hd l"
+  sorry
+
+lemma EL_LENGTH_SNOC: "EL (length l) (SNOC x l) = x"
+  sorry
+
+lemma EL_PRE_LENGTH: "l ~= [] ==> EL (PRE (length l)) l = last l"
+  sorry
+
+lemma EL_SNOC: "n < length l ==> EL n (SNOC x l) = EL n l"
+  sorry
+
+lemma EL_ELL: "n < length l ==> EL n l = ELL (PRE (length l - n)) l"
+  sorry
+
+lemma EL_LENGTH_APPEND: "~ List.null l2 ==> EL (length l1) (l1 @ l2) = hd l2"
+  sorry
+
+lemma ELL_EL: "n < length l ==> ELL n l = EL (PRE (length l - n)) l"
+  sorry
+
+lemma ELL_MAP: "n < length l ==> ELL n (map f l) = f (ELL n l)"
+  sorry
+
+lemma LENGTH_BUTLAST: "l ~= [] ==> length (butlast l) = PRE (length l)"
+  sorry
+
+lemma BUTFIRSTN_LENGTH_APPEND: "BUTFIRSTN (length l1) (l1 @ l2) = l2"
+  sorry
+
+lemma FIRSTN_APPEND1: "n <= length l1 ==> FIRSTN n (l1 @ l2) = FIRSTN n l1"
+  sorry
+
+lemma FIRSTN_APPEND2: "length l1 <= n ==> FIRSTN n (l1 @ l2) = l1 @ FIRSTN (n - length l1) l2"
+  sorry
+
+lemma FIRSTN_LENGTH_APPEND: "FIRSTN (length l1) (l1 @ l2) = l1"
+  sorry
+
+lemma REVERSE_FLAT: "rev (concat l) = concat (rev (map rev l))"
+  sorry
+
+lemma MAP_FILTER: "(!!x. P (f x) = P x) ==> map f (filter P l) = filter P (map f l)"
+  sorry
+
+lemma FLAT_REVERSE: "concat (rev l) = rev (concat (map rev l))"
+  sorry
+
+lemma FLAT_FLAT: "concat (concat l) = concat (map concat l)"
+  sorry
+
+lemma ALL_EL_SEG: "[| list_all P l; m + k <= length l |] ==> list_all P (SEG m k l)"
+  sorry
+
+lemma ALL_EL_FIRSTN: "[| list_all P l; m <= length l |] ==> list_all P (FIRSTN m l)"
+  sorry
+
+lemma ALL_EL_BUTFIRSTN: "[| list_all P l; m <= length l |] ==> list_all P (BUTFIRSTN m l)"
+  sorry
+
+lemma SOME_EL_SEG: "[| m + k <= length l; list_ex P (SEG m k l) |] ==> list_ex P l"
+  sorry
+
+lemma SOME_EL_FIRSTN: "[| m <= length l; list_ex P (FIRSTN m l) |] ==> list_ex P l"
+  sorry
+
+lemma SOME_EL_BUTFIRSTN: "[| m <= length l; list_ex P (BUTFIRSTN m l) |] ==> list_ex P l"
+  sorry
+
+lemma SOME_EL_LASTN: "[| m <= length l; list_ex P (LASTN m l) |] ==> list_ex P l"
+  sorry
+
+lemma SOME_EL_BUTLASTN: "[| m <= length l; list_ex P (BUTLASTN m l) |] ==> list_ex P l"
+  sorry
+
+lemma IS_EL_REVERSE: "List.member (rev l) x = List.member l x"
+  sorry
+
+lemma IS_EL_FILTER: "P x ==> List.member (filter P l) x = List.member l x"
+  sorry
+
+lemma IS_EL_SEG: "[| n + m <= length l; List.member (SEG n m l) x |] ==> List.member l x"
+  sorry
+
+lemma IS_EL_SOME_EL: "List.member l x = list_ex (op = x) l"
+  sorry
+
+lemma IS_EL_FIRSTN: "[| x <= length xa; List.member (FIRSTN x xa) xb |] ==> List.member xa xb"
+  sorry
+
+lemma IS_EL_BUTFIRSTN: "[| x <= length xa; List.member (BUTFIRSTN x xa) xb |] ==> List.member xa xb"
+  sorry
+
+lemma IS_EL_BUTLASTN: "[| x <= length xa; List.member (BUTLASTN x xa) xb |] ==> List.member xa xb"
+  sorry
+
+lemma IS_EL_LASTN: "[| x <= length xa; List.member (LASTN x xa) xb |] ==> List.member xa xb"
+  sorry
+
+lemma ZIP_SNOC: "length l1 = length l2
+==> zip (SNOC x1 l1) (SNOC x2 l2) = SNOC (x1, x2) (zip l1 l2)"
+  sorry
+
+lemma UNZIP_SNOC: "unzip (SNOC x l) =
+(SNOC (fst x) (fst (unzip l)), SNOC (snd x) (snd (unzip l)))"
+  sorry
+
+lemma LENGTH_UNZIP_FST: "length (UNZIP_FST x) = length x"
+  sorry
+
+lemma LENGTH_UNZIP_SND: "length (UNZIP_SND (x::('a * 'b) list)) = length x"
+  sorry
+
+lemma SUM_APPEND: "Compatibility.sum (l1 @ l2) = Compatibility.sum l1 + Compatibility.sum l2"
+  sorry
+
+lemma SUM_REVERSE: "Compatibility.sum (rev l) = Compatibility.sum l"
+  sorry
+
+lemma SUM_FLAT: "Compatibility.sum (concat l) = Compatibility.sum (map Compatibility.sum l)"
+  sorry
+
+lemma EL_APPEND1: "n < length l1 ==> EL n (l1 @ l2) = EL n l1"
+  sorry
+
+lemma EL_APPEND2: "length l1 <= n ==> EL n (l1 @ l2) = EL (n - length l1) l2"
+  sorry
+
+lemma EL_MAP: "n < length l ==> EL n (map f l) = f (EL n l)"
+  sorry
+
+lemma EL_CONS: "0 < n ==> EL n (x # l) = EL (PRE n) l"
+  sorry
+
+lemma EL_SEG: "n < length l ==> EL n l = hd (SEG 1 n l)"
+  sorry
+
+lemma EL_IS_EL: "n < length l ==> List.member l (EL n l)"
+  sorry
+
+lemma TL_SNOC: "tl (SNOC x l) = (if List.null l then [] else SNOC x (tl l))"
+  sorry
+
+lemma EL_REVERSE: "n < length l ==> EL n (rev l) = EL (PRE (length l - n)) l"
+  sorry
+
+lemma EL_REVERSE_ELL: "n < length l ==> EL n (rev l) = ELL n l"
+  sorry
+
+lemma ELL_LENGTH_APPEND: "~ List.null l1 ==> ELL (length l2) (l1 @ l2) = last l1"
+  sorry
+
+lemma ELL_IS_EL: "n < length l ==> List.member l (ELL n l)"
+  sorry
+
+lemma ELL_REVERSE: "n < length l ==> ELL n (rev l) = ELL (PRE (length l - n)) l"
+  sorry
+
+lemma ELL_REVERSE_EL: "n < length l ==> ELL n (rev l) = EL n l"
+  sorry
+
+lemma FIRSTN_BUTLASTN: "n <= length l ==> FIRSTN n l = BUTLASTN (length l - n) l"
+  sorry
+
+lemma BUTLASTN_FIRSTN: "n <= length l ==> BUTLASTN n l = FIRSTN (length l - n) l"
+  sorry
+
+lemma LASTN_BUTFIRSTN: "n <= length l ==> LASTN n l = BUTFIRSTN (length l - n) l"
+  sorry
+
+lemma BUTFIRSTN_LASTN: "n <= length l ==> BUTFIRSTN n l = LASTN (length l - n) l"
+  sorry
+
+lemma SEG_LASTN_BUTLASTN: "n + m <= length l ==> SEG n m l = LASTN n (BUTLASTN (length l - (n + m)) l)"
+  sorry
+
+lemma BUTFIRSTN_REVERSE: "n <= length l ==> BUTFIRSTN n (rev l) = rev (BUTLASTN n l)"
+  sorry
+
+lemma BUTLASTN_REVERSE: "n <= length l ==> BUTLASTN n (rev l) = rev (BUTFIRSTN n l)"
+  sorry
+
+lemma LASTN_REVERSE: "n <= length l ==> LASTN n (rev l) = rev (FIRSTN n l)"
+  sorry
+
+lemma FIRSTN_REVERSE: "n <= length l ==> FIRSTN n (rev l) = rev (LASTN n l)"
+  sorry
+
+lemma SEG_REVERSE: "n + m <= length l ==> SEG n m (rev l) = rev (SEG n (length l - (n + m)) l)"
+  sorry
+
+lemma LENGTH_GENLIST: "length (GENLIST f n) = n"
+  sorry
+
+lemma LENGTH_REPLICATE: "length (REPLICATE n x) = n"
+  sorry
+
+lemma IS_EL_REPLICATE: "0 < n ==> List.member (REPLICATE n x) x"
+  sorry
+
+lemma ALL_EL_REPLICATE: "list_all (op = x) (REPLICATE n x)"
+  sorry
+
+lemma AND_EL_FOLDL: "AND_EL l = foldl op & True l"
+  sorry
+
+lemma AND_EL_FOLDR: "AND_EL l = foldr op & l True"
+  sorry
+
+lemma OR_EL_FOLDL: "OR_EL l = foldl op | False l"
+  sorry
+
+lemma OR_EL_FOLDR: "OR_EL l = foldr op | l False"
+  sorry
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" state_transformer
+
+definition
+  UNIT :: "'b => 'a => 'b * 'a"  where
+  "(op ==::('b::type => 'a::type => 'b::type * 'a::type)
+        => ('b::type => 'a::type => 'b::type * 'a::type) => prop)
+ (UNIT::'b::type => 'a::type => 'b::type * 'a::type)
+ (Pair::'b::type => 'a::type => 'b::type * 'a::type)"
+
+lemma UNIT_DEF: "UNIT x = Pair x"
+  sorry
+
+definition
+  BIND :: "('a => 'b * 'a) => ('b => 'a => 'c * 'a) => 'a => 'c * 'a"  where
+  "BIND == %g f. (%(x, y). f x y) o g"
+
+lemma BIND_DEF: "BIND (g::'a => 'b * 'a) (f::'b => 'a => 'c * 'a) =
+(%(x::'b, y::'a). f x y) o g"
+  sorry
+
+definition
+  MMAP :: "('c => 'b) => ('a => 'c * 'a) => 'a => 'b * 'a"  where
+  "MMAP == %(f::'c => 'b) m::'a => 'c * 'a. BIND m (UNIT o f)"
+
+lemma MMAP_DEF: "MMAP f m = BIND m (UNIT o f)"
+  sorry
+
+definition
+  JOIN :: "('a => ('a => 'b * 'a) * 'a) => 'a => 'b * 'a"  where
+  "JOIN == %z. BIND z I"
+
+lemma JOIN_DEF: "JOIN z = BIND z I"
+  sorry
+
+lemma BIND_LEFT_UNIT: "BIND (UNIT (x::'a)) (k::'a => 'b => 'c * 'b) = k x"
+  sorry
+
+lemma UNIT_UNCURRY: "prod_case UNIT x = x"
+  sorry
+
+lemma BIND_RIGHT_UNIT: "BIND k UNIT = k"
+  sorry
+
+lemma BIND_ASSOC: "BIND (x::'a => 'b * 'a)
+ (%a::'b. BIND ((xa::'b => 'a => 'c * 'a) a) (xb::'c => 'a => 'd * 'a)) =
+BIND (BIND x xa) xb"
+  sorry
+
+lemma MMAP_ID: "MMAP I = I"
+  sorry
+
+lemma MMAP_COMP: "MMAP ((f::'c => 'd) o (g::'b => 'c)) = MMAP f o MMAP g"
+  sorry
+
+lemma MMAP_UNIT: "MMAP (f::'b => 'c) o UNIT = UNIT o f"
+  sorry
+
+lemma MMAP_JOIN: "MMAP f o JOIN = JOIN o MMAP (MMAP f)"
+  sorry
+
+lemma JOIN_UNIT: "JOIN o UNIT = I"
+  sorry
+
+lemma JOIN_MMAP_UNIT: "JOIN o MMAP UNIT = I"
+  sorry
+
+lemma JOIN_MAP_JOIN: "JOIN o MMAP JOIN = JOIN o JOIN"
+  sorry
+
+lemma JOIN_MAP: "BIND (x::'a => 'b * 'a) (xa::'b => 'a => 'c * 'a) = JOIN (MMAP xa x)"
+  sorry
+
+lemma FST_o_UNIT: "fst o UNIT (x::'a) = K x"
+  sorry
+
+lemma SND_o_UNIT: "snd o UNIT (x::'a) = I"
+  sorry
+
+lemma FST_o_MMAP: "fst o MMAP (x::'a => 'b) (xa::'c => 'a * 'c) = x o (fst o xa)"
+  sorry
+
+;end_setup
+
+end
+
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/HOL4Prob.thy
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/HOL4Prob.thy	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,1594 @@
+(* 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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/HOL4Real.thy
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/HOL4Real.thy	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,2950 @@
+(* AUTOMATICALLY GENERATED, DO NOT EDIT! *)
+
+theory HOL4Real imports HOL4Base begin
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" realax
+
+lemma HREAL_RDISTRIB: "hreal_mul (hreal_add x y) z = hreal_add (hreal_mul x z) (hreal_mul y z)"
+  by (import realax HREAL_RDISTRIB)
+
+lemma HREAL_EQ_ADDL: "x ~= hreal_add x y"
+  by (import realax HREAL_EQ_ADDL)
+
+lemma HREAL_EQ_LADD: "(hreal_add x y = hreal_add x z) = (y = z)"
+  by (import realax HREAL_EQ_LADD)
+
+lemma HREAL_LT_REFL: "~ hreal_lt x x"
+  by (import realax HREAL_LT_REFL)
+
+lemma HREAL_LT_ADDL: "hreal_lt x (hreal_add x y)"
+  by (import realax HREAL_LT_ADDL)
+
+lemma HREAL_LT_NE: "hreal_lt x y ==> x ~= y"
+  by (import realax HREAL_LT_NE)
+
+lemma HREAL_LT_ADDR: "~ hreal_lt (hreal_add x y) x"
+  by (import realax HREAL_LT_ADDR)
+
+lemma HREAL_LT_GT: "hreal_lt x y ==> ~ hreal_lt y x"
+  by (import realax HREAL_LT_GT)
+
+lemma HREAL_LT_ADD2: "hreal_lt x1 y1 & hreal_lt x2 y2
+==> hreal_lt (hreal_add x1 x2) (hreal_add y1 y2)"
+  by (import realax HREAL_LT_ADD2)
+
+lemma HREAL_LT_LADD: "hreal_lt (hreal_add x y) (hreal_add x z) = hreal_lt y z"
+  by (import realax HREAL_LT_LADD)
+
+definition
+  treal_0 :: "hreal * hreal"  where
+  "treal_0 == (hreal_1, hreal_1)"
+
+lemma treal_0: "treal_0 = (hreal_1, hreal_1)"
+  by (import realax treal_0)
+
+definition
+  treal_1 :: "hreal * hreal"  where
+  "treal_1 == (hreal_add hreal_1 hreal_1, hreal_1)"
+
+lemma treal_1: "treal_1 = (hreal_add hreal_1 hreal_1, hreal_1)"
+  by (import realax treal_1)
+
+definition
+  treal_neg :: "hreal * hreal => hreal * hreal"  where
+  "treal_neg == %(x, y). (y, x)"
+
+lemma treal_neg: "treal_neg (x, y) = (y, x)"
+  by (import realax treal_neg)
+
+definition
+  treal_add :: "hreal * hreal => hreal * hreal => hreal * hreal"  where
+  "treal_add == %(x1, y1) (x2, y2). (hreal_add x1 x2, hreal_add y1 y2)"
+
+lemma treal_add: "treal_add (x1, y1) (x2, y2) = (hreal_add x1 x2, hreal_add y1 y2)"
+  by (import realax treal_add)
+
+definition
+  treal_mul :: "hreal * hreal => hreal * hreal => hreal * hreal"  where
+  "treal_mul ==
+%(x1, y1) (x2, y2).
+   (hreal_add (hreal_mul x1 x2) (hreal_mul y1 y2),
+    hreal_add (hreal_mul x1 y2) (hreal_mul y1 x2))"
+
+lemma treal_mul: "treal_mul (x1, y1) (x2, y2) =
+(hreal_add (hreal_mul x1 x2) (hreal_mul y1 y2),
+ hreal_add (hreal_mul x1 y2) (hreal_mul y1 x2))"
+  by (import realax treal_mul)
+
+definition
+  treal_lt :: "hreal * hreal => hreal * hreal => bool"  where
+  "treal_lt == %(x1, y1) (x2, y2). hreal_lt (hreal_add x1 y2) (hreal_add x2 y1)"
+
+lemma treal_lt: "treal_lt (x1, y1) (x2, y2) = hreal_lt (hreal_add x1 y2) (hreal_add x2 y1)"
+  by (import realax treal_lt)
+
+definition
+  treal_inv :: "hreal * hreal => hreal * hreal"  where
+  "treal_inv ==
+%(x, y).
+   if x = y then treal_0
+   else if hreal_lt y x
+        then (hreal_add (hreal_inv (hreal_sub x y)) hreal_1, hreal_1)
+        else (hreal_1, hreal_add (hreal_inv (hreal_sub y x)) hreal_1)"
+
+lemma treal_inv: "treal_inv (x, y) =
+(if x = y then treal_0
+ else if hreal_lt y x
+      then (hreal_add (hreal_inv (hreal_sub x y)) hreal_1, hreal_1)
+      else (hreal_1, hreal_add (hreal_inv (hreal_sub y x)) hreal_1))"
+  by (import realax treal_inv)
+
+definition
+  treal_eq :: "hreal * hreal => hreal * hreal => bool"  where
+  "treal_eq == %(x1, y1) (x2, y2). hreal_add x1 y2 = hreal_add x2 y1"
+
+lemma treal_eq: "treal_eq (x1, y1) (x2, y2) = (hreal_add x1 y2 = hreal_add x2 y1)"
+  by (import realax treal_eq)
+
+lemma TREAL_EQ_REFL: "treal_eq x x"
+  by (import realax TREAL_EQ_REFL)
+
+lemma TREAL_EQ_SYM: "treal_eq x y = treal_eq y x"
+  by (import realax TREAL_EQ_SYM)
+
+lemma TREAL_EQ_TRANS: "treal_eq x y & treal_eq y z ==> treal_eq x z"
+  by (import realax TREAL_EQ_TRANS)
+
+lemma TREAL_EQ_EQUIV: "treal_eq p q = (treal_eq p = treal_eq q)"
+  by (import realax TREAL_EQ_EQUIV)
+
+lemma TREAL_EQ_AP: "p = q ==> treal_eq p q"
+  by (import realax TREAL_EQ_AP)
+
+lemma TREAL_10: "~ treal_eq treal_1 treal_0"
+  by (import realax TREAL_10)
+
+lemma TREAL_ADD_SYM: "treal_add x y = treal_add y x"
+  by (import realax TREAL_ADD_SYM)
+
+lemma TREAL_MUL_SYM: "treal_mul x y = treal_mul y x"
+  by (import realax TREAL_MUL_SYM)
+
+lemma TREAL_ADD_ASSOC: "treal_add x (treal_add y z) = treal_add (treal_add x y) z"
+  by (import realax TREAL_ADD_ASSOC)
+
+lemma TREAL_MUL_ASSOC: "treal_mul x (treal_mul y z) = treal_mul (treal_mul x y) z"
+  by (import realax TREAL_MUL_ASSOC)
+
+lemma TREAL_LDISTRIB: "treal_mul x (treal_add y z) = treal_add (treal_mul x y) (treal_mul x z)"
+  by (import realax TREAL_LDISTRIB)
+
+lemma TREAL_ADD_LID: "treal_eq (treal_add treal_0 x) x"
+  by (import realax TREAL_ADD_LID)
+
+lemma TREAL_MUL_LID: "treal_eq (treal_mul treal_1 x) x"
+  by (import realax TREAL_MUL_LID)
+
+lemma TREAL_ADD_LINV: "treal_eq (treal_add (treal_neg x) x) treal_0"
+  by (import realax TREAL_ADD_LINV)
+
+lemma TREAL_INV_0: "treal_eq (treal_inv treal_0) treal_0"
+  by (import realax TREAL_INV_0)
+
+lemma TREAL_MUL_LINV: "~ treal_eq x treal_0 ==> treal_eq (treal_mul (treal_inv x) x) treal_1"
+  by (import realax TREAL_MUL_LINV)
+
+lemma TREAL_LT_TOTAL: "treal_eq x y | treal_lt x y | treal_lt y x"
+  by (import realax TREAL_LT_TOTAL)
+
+lemma TREAL_LT_REFL: "~ treal_lt x x"
+  by (import realax TREAL_LT_REFL)
+
+lemma TREAL_LT_TRANS: "treal_lt x y & treal_lt y z ==> treal_lt x z"
+  by (import realax TREAL_LT_TRANS)
+
+lemma TREAL_LT_ADD: "treal_lt y z ==> treal_lt (treal_add x y) (treal_add x z)"
+  by (import realax TREAL_LT_ADD)
+
+lemma TREAL_LT_MUL: "treal_lt treal_0 x & treal_lt treal_0 y ==> treal_lt treal_0 (treal_mul x y)"
+  by (import realax TREAL_LT_MUL)
+
+definition
+  treal_of_hreal :: "hreal => hreal * hreal"  where
+  "treal_of_hreal == %x. (hreal_add x hreal_1, hreal_1)"
+
+lemma treal_of_hreal: "treal_of_hreal x = (hreal_add x hreal_1, hreal_1)"
+  by (import realax treal_of_hreal)
+
+definition
+  hreal_of_treal :: "hreal * hreal => hreal"  where
+  "hreal_of_treal == %(x, y). SOME d. x = hreal_add y d"
+
+lemma hreal_of_treal: "hreal_of_treal (x, y) = (SOME d. x = hreal_add y d)"
+  by (import realax hreal_of_treal)
+
+lemma TREAL_BIJ: "(ALL h. hreal_of_treal (treal_of_hreal h) = h) &
+(ALL r. treal_lt treal_0 r = treal_eq (treal_of_hreal (hreal_of_treal r)) r)"
+  by (import realax TREAL_BIJ)
+
+lemma TREAL_ISO: "hreal_lt h i ==> treal_lt (treal_of_hreal h) (treal_of_hreal i)"
+  by (import realax TREAL_ISO)
+
+lemma TREAL_BIJ_WELLDEF: "treal_eq h i ==> hreal_of_treal h = hreal_of_treal i"
+  by (import realax TREAL_BIJ_WELLDEF)
+
+lemma TREAL_NEG_WELLDEF: "treal_eq x1 x2 ==> treal_eq (treal_neg x1) (treal_neg x2)"
+  by (import realax TREAL_NEG_WELLDEF)
+
+lemma TREAL_ADD_WELLDEFR: "treal_eq x1 x2 ==> treal_eq (treal_add x1 y) (treal_add x2 y)"
+  by (import realax TREAL_ADD_WELLDEFR)
+
+lemma TREAL_ADD_WELLDEF: "treal_eq x1 x2 & treal_eq y1 y2
+==> treal_eq (treal_add x1 y1) (treal_add x2 y2)"
+  by (import realax TREAL_ADD_WELLDEF)
+
+lemma TREAL_MUL_WELLDEFR: "treal_eq x1 x2 ==> treal_eq (treal_mul x1 y) (treal_mul x2 y)"
+  by (import realax TREAL_MUL_WELLDEFR)
+
+lemma TREAL_MUL_WELLDEF: "treal_eq x1 x2 & treal_eq y1 y2
+==> treal_eq (treal_mul x1 y1) (treal_mul x2 y2)"
+  by (import realax TREAL_MUL_WELLDEF)
+
+lemma TREAL_LT_WELLDEFR: "treal_eq x1 x2 ==> treal_lt x1 y = treal_lt x2 y"
+  by (import realax TREAL_LT_WELLDEFR)
+
+lemma TREAL_LT_WELLDEFL: "treal_eq y1 y2 ==> treal_lt x y1 = treal_lt x y2"
+  by (import realax TREAL_LT_WELLDEFL)
+
+lemma TREAL_LT_WELLDEF: "treal_eq x1 x2 & treal_eq y1 y2 ==> treal_lt x1 y1 = treal_lt x2 y2"
+  by (import realax TREAL_LT_WELLDEF)
+
+lemma TREAL_INV_WELLDEF: "treal_eq x1 x2 ==> treal_eq (treal_inv x1) (treal_inv x2)"
+  by (import realax TREAL_INV_WELLDEF)
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" real
+
+lemma REAL_0: "(0::real) = (0::real)"
+  by (import real REAL_0)
+
+lemma REAL_1: "(1::real) = (1::real)"
+  by (import real REAL_1)
+
+lemma REAL_ADD_LID_UNIQ: "((x::real) + (y::real) = y) = (x = (0::real))"
+  by (import real REAL_ADD_LID_UNIQ)
+
+lemma REAL_ADD_RID_UNIQ: "((x::real) + (y::real) = x) = (y = (0::real))"
+  by (import real REAL_ADD_RID_UNIQ)
+
+lemma REAL_LT_ANTISYM: "~ ((x::real) < (y::real) & y < x)"
+  by (import real REAL_LT_ANTISYM)
+
+lemma REAL_LTE_TOTAL: "(x::real) < (y::real) | y <= x"
+  by (import real REAL_LTE_TOTAL)
+
+lemma REAL_LET_ANTISYM: "~ ((x::real) < (y::real) & y <= x)"
+  by (import real REAL_LET_ANTISYM)
+
+lemma REAL_LTE_ANTSYM: "~ ((x::real) <= (y::real) & y < x)"
+  by (import real REAL_LTE_ANTSYM)
+
+lemma REAL_LT_NEGTOTAL: "(x::real) = (0::real) | (0::real) < x | (0::real) < - x"
+  by (import real REAL_LT_NEGTOTAL)
+
+lemma REAL_LE_NEGTOTAL: "(0::real) <= (x::real) | (0::real) <= - x"
+  by (import real REAL_LE_NEGTOTAL)
+
+lemma REAL_LT_ADDNEG: "((y::real) < (x::real) + - (z::real)) = (y + z < x)"
+  by (import real REAL_LT_ADDNEG)
+
+lemma REAL_LT_ADDNEG2: "((x::real) + - (y::real) < (z::real)) = (x < z + y)"
+  by (import real REAL_LT_ADDNEG2)
+
+lemma REAL_LT_ADD1: "(x::real) <= (y::real) ==> x < y + (1::real)"
+  by (import real REAL_LT_ADD1)
+
+lemma REAL_SUB_ADD2: "(y::real) + ((x::real) - y) = x"
+  by (import real REAL_SUB_ADD2)
+
+lemma REAL_SUB_LT: "((0::real) < (x::real) - (y::real)) = (y < x)"
+  by (import real REAL_SUB_LT)
+
+lemma REAL_SUB_LE: "((0::real) <= (x::real) - (y::real)) = (y <= x)"
+  by (import real REAL_SUB_LE)
+
+lemma REAL_ADD_SUB: "(x::real) + (y::real) - x = y"
+  by (import real REAL_ADD_SUB)
+
+lemma REAL_NEG_EQ: "(- (x::real) = (y::real)) = (x = - y)"
+  by (import real REAL_NEG_EQ)
+
+lemma REAL_LT_LMUL_0: "(0::real) < (x::real) ==> ((0::real) < x * (y::real)) = ((0::real) < y)"
+  by (import real REAL_LT_LMUL_0)
+
+lemma REAL_LT_RMUL_0: "(0::real) < (y::real) ==> ((0::real) < (x::real) * y) = ((0::real) < x)"
+  by (import real REAL_LT_RMUL_0)
+
+lemma REAL_LINV_UNIQ: "(x::real) * (y::real) = (1::real) ==> x = inverse y"
+  by (import real REAL_LINV_UNIQ)
+
+lemma REAL_LE_INV: "(0::real) <= (x::real) ==> (0::real) <= inverse x"
+  by (import real REAL_LE_INV)
+
+lemma REAL_LE_ADDR: "((x::real) <= x + (y::real)) = ((0::real) <= y)"
+  by (import real REAL_LE_ADDR)
+
+lemma REAL_LE_ADDL: "((y::real) <= (x::real) + y) = ((0::real) <= x)"
+  by (import real REAL_LE_ADDL)
+
+lemma REAL_LT_ADDR: "((x::real) < x + (y::real)) = ((0::real) < y)"
+  by (import real REAL_LT_ADDR)
+
+lemma REAL_LT_ADDL: "((y::real) < (x::real) + y) = ((0::real) < x)"
+  by (import real REAL_LT_ADDL)
+
+lemma REAL_LT_NZ: "(real (n::nat) ~= (0::real)) = ((0::real) < real n)"
+  by (import real REAL_LT_NZ)
+
+lemma REAL_NZ_IMP_LT: "(n::nat) ~= (0::nat) ==> (0::real) < real n"
+  by (import real REAL_NZ_IMP_LT)
+
+lemma REAL_LT_RDIV_0: "(0::real) < (z::real) ==> ((0::real) < (y::real) / z) = ((0::real) < y)"
+  by (import real REAL_LT_RDIV_0)
+
+lemma REAL_LT_RDIV: "(0::real) < (z::real) ==> ((x::real) / z < (y::real) / z) = (x < y)"
+  by (import real REAL_LT_RDIV)
+
+lemma REAL_LT_FRACTION_0: "(n::nat) ~= (0::nat) ==> ((0::real) < (d::real) / real n) = ((0::real) < d)"
+  by (import real REAL_LT_FRACTION_0)
+
+lemma REAL_LT_MULTIPLE: "(1::nat) < (x::nat) ==> ((xa::real) < real x * xa) = ((0::real) < xa)"
+  by (import real REAL_LT_MULTIPLE)
+
+lemma REAL_LT_FRACTION: "(1::nat) < (n::nat) ==> ((d::real) / real n < d) = ((0::real) < d)"
+  by (import real REAL_LT_FRACTION)
+
+lemma REAL_LT_HALF2: "((d::real) / (2::real) < d) = ((0::real) < d)"
+  by (import real REAL_LT_HALF2)
+
+lemma REAL_DIV_LMUL: "(y::real) ~= (0::real) ==> y * ((x::real) / y) = x"
+  by (import real REAL_DIV_LMUL)
+
+lemma REAL_DIV_RMUL: "(y::real) ~= (0::real) ==> (x::real) / y * y = x"
+  by (import real REAL_DIV_RMUL)
+
+lemma REAL_DOWN: "(0::real) < (x::real) ==> EX xa>0::real. xa < x"
+  by (import real REAL_DOWN)
+
+lemma REAL_SUB_SUB: "(x::real) - (y::real) - x = - y"
+  by (import real REAL_SUB_SUB)
+
+lemma REAL_SUB_LNEG: "- (x::real) - (y::real) = - (x + y)"
+  by (import real REAL_SUB_LNEG)
+
+lemma REAL_SUB_NEG2: "- (x::real) - - (y::real) = y - x"
+  by (import real REAL_SUB_NEG2)
+
+lemma REAL_SUB_TRIANGLE: "(a::real) - (b::real) + (b - (c::real)) = a - c"
+  by (import real REAL_SUB_TRIANGLE)
+
+lemma REAL_INV_MUL: "(x::real) ~= (0::real) & (y::real) ~= (0::real)
+==> inverse (x * y) = inverse x * inverse y"
+  by (import real REAL_INV_MUL)
+
+lemma REAL_SUB_INV2: "(x::real) ~= (0::real) & (y::real) ~= (0::real)
+==> inverse x - inverse y = (y - x) / (x * y)"
+  by (import real REAL_SUB_INV2)
+
+lemma REAL_SUB_SUB2: "(x::real) - (x - (y::real)) = y"
+  by (import real REAL_SUB_SUB2)
+
+lemma REAL_ADD_SUB2: "(x::real) - (x + (y::real)) = - y"
+  by (import real REAL_ADD_SUB2)
+
+lemma REAL_LE_DIV: "(0::real) <= (x::real) & (0::real) <= (xa::real) ==> (0::real) <= x / xa"
+  by (import real REAL_LE_DIV)
+
+lemma REAL_LT_1: "(0::real) <= (x::real) & x < (y::real) ==> x / y < (1::real)"
+  by (import real REAL_LT_1)
+
+lemma REAL_POS_NZ: "(0::real) < (x::real) ==> x ~= (0::real)"
+  by (import real REAL_POS_NZ)
+
+lemma REAL_EQ_RMUL_IMP: "(z::real) ~= (0::real) & (x::real) * z = (y::real) * z ==> x = y"
+  by (import real REAL_EQ_RMUL_IMP)
+
+lemma REAL_EQ_LMUL_IMP: "(x::real) ~= (0::real) & x * (xa::real) = x * (xb::real) ==> xa = xb"
+  by (import real REAL_EQ_LMUL_IMP)
+
+lemma REAL_FACT_NZ: "real (FACT n) ~= 0"
+  by (import real REAL_FACT_NZ)
+
+lemma REAL_POASQ: "((0::real) < (x::real) * x) = (x ~= (0::real))"
+  by (import real REAL_POASQ)
+
+lemma REAL_DIV_MUL2: "(x::real) ~= (0::real) & (z::real) ~= (0::real)
+==> (y::real) / z = x * y / (x * z)"
+  by (import real REAL_DIV_MUL2)
+
+lemma REAL_MIDDLE1: "(a::real) <= (b::real) ==> a <= (a + b) / (2::real)"
+  by (import real REAL_MIDDLE1)
+
+lemma REAL_MIDDLE2: "(a::real) <= (b::real) ==> (a + b) / (2::real) <= b"
+  by (import real REAL_MIDDLE2)
+
+lemma ABS_LT_MUL2: "abs (w::real) < (y::real) & abs (x::real) < (z::real)
+==> abs (w * x) < y * z"
+  by (import real ABS_LT_MUL2)
+
+lemma ABS_REFL: "(abs (x::real) = x) = ((0::real) <= x)"
+  by (import real ABS_REFL)
+
+lemma ABS_BETWEEN: "((0::real) < (d::real) & (x::real) - d < (y::real) & y < x + d) =
+(abs (y - x) < d)"
+  by (import real ABS_BETWEEN)
+
+lemma ABS_BOUND: "abs ((x::real) - (y::real)) < (d::real) ==> y < x + d"
+  by (import real ABS_BOUND)
+
+lemma ABS_STILLNZ: "abs ((x::real) - (y::real)) < abs y ==> x ~= (0::real)"
+  by (import real ABS_STILLNZ)
+
+lemma ABS_CASES: "(x::real) = (0::real) | (0::real) < abs x"
+  by (import real ABS_CASES)
+
+lemma ABS_BETWEEN1: "(x::real) < (z::real) & abs ((y::real) - x) < z - x ==> y < z"
+  by (import real ABS_BETWEEN1)
+
+lemma ABS_SIGN: "abs ((x::real) - (y::real)) < y ==> (0::real) < x"
+  by (import real ABS_SIGN)
+
+lemma ABS_SIGN2: "abs ((x::real) - (y::real)) < - y ==> x < (0::real)"
+  by (import real ABS_SIGN2)
+
+lemma ABS_CIRCLE: "abs (h::real) < abs (y::real) - abs (x::real) ==> abs (x + h) < abs y"
+  by (import real ABS_CIRCLE)
+
+lemma ABS_BETWEEN2: "(x0::real) < (y0::real) &
+abs ((x::real) - x0) < (y0 - x0) / (2::real) &
+abs ((y::real) - y0) < (y0 - x0) / (2::real)
+==> x < y"
+  by (import real ABS_BETWEEN2)
+
+lemma POW_PLUS1: "0 < e ==> 1 + real n * e <= (1 + e) ^ n"
+  by (import real POW_PLUS1)
+
+lemma POW_M1: "abs ((- (1::real)) ^ (n::nat)) = (1::real)"
+  by (import real POW_M1)
+
+lemma REAL_LE1_POW2: "(1::real) <= (x::real) ==> (1::real) <= x ^ (2::nat)"
+  by (import real REAL_LE1_POW2)
+
+lemma REAL_LT1_POW2: "(1::real) < (x::real) ==> (1::real) < x ^ (2::nat)"
+  by (import real REAL_LT1_POW2)
+
+lemma POW_POS_LT: "(0::real) < (x::real) ==> (0::real) < x ^ Suc (n::nat)"
+  by (import real POW_POS_LT)
+
+lemma POW_LT: "(0::real) <= (x::real) & x < (y::real) ==> x ^ Suc (n::nat) < y ^ Suc n"
+  by (import real POW_LT)
+
+lemma POW_ZERO: "(x::real) ^ (n::nat) = (0::real) ==> x = (0::real)"
+  by (import real POW_ZERO)
+
+lemma POW_ZERO_EQ: "((x::real) ^ Suc (n::nat) = (0::real)) = (x = (0::real))"
+  by (import real POW_ZERO_EQ)
+
+lemma REAL_POW_LT2: "(n::nat) ~= (0::nat) & (0::real) <= (x::real) & x < (y::real)
+==> x ^ n < y ^ n"
+  by (import real REAL_POW_LT2)
+
+lemma REAL_POW_MONO_LT: "(1::real) < (x::real) & (m::nat) < (n::nat) ==> x ^ m < x ^ n"
+  by (import real REAL_POW_MONO_LT)
+
+lemma REAL_SUP_SOMEPOS: "(EX x::real. (P::real => bool) x & (0::real) < x) &
+(EX z::real. ALL x::real. P x --> x < z)
+==> EX s::real. ALL y::real. (EX x::real. P x & y < x) = (y < s)"
+  by (import real REAL_SUP_SOMEPOS)
+
+lemma SUP_LEMMA1: "(!!y::real.
+    (EX x::real. (P::real => bool) (x + (d::real)) & y < x) =
+    (y < (s::real)))
+==> (EX x::real. P x & (y::real) < x) = (y < s + d)"
+  by (import real SUP_LEMMA1)
+
+lemma SUP_LEMMA2: "Ex (P::real => bool) ==> EX (d::real) x::real. P (x + d) & (0::real) < x"
+  by (import real SUP_LEMMA2)
+
+lemma SUP_LEMMA3: "EX z::real. ALL x::real. (P::real => bool) x --> x < z
+==> EX x::real. ALL xa::real. P (xa + (d::real)) --> xa < x"
+  by (import real SUP_LEMMA3)
+
+lemma REAL_SUP_EXISTS: "Ex (P::real => bool) & (EX z::real. ALL x::real. P x --> x < z)
+==> EX x::real. ALL y::real. (EX x::real. P x & y < x) = (y < x)"
+  by (import real REAL_SUP_EXISTS)
+
+consts
+  sup :: "(real => bool) => real" 
+
+defs
+  sup_def: "real.sup == %P. SOME s. ALL y. (EX x. P x & y < x) = (y < s)"
+
+lemma sup: "real.sup P = (SOME s. ALL y. (EX x. P x & y < x) = (y < s))"
+  by (import real sup)
+
+lemma REAL_SUP: "Ex P & (EX z. ALL x. P x --> x < z)
+==> (EX x. P x & y < x) = (y < real.sup P)"
+  by (import real REAL_SUP)
+
+lemma REAL_SUP_UBOUND: "[| Ex P & (EX z. ALL x. P x --> x < z); P y |] ==> y <= real.sup P"
+  by (import real REAL_SUP_UBOUND)
+
+lemma SETOK_LE_LT: "(Ex (P::real => bool) & (EX z::real. ALL x::real. P x --> x <= z)) =
+(Ex P & (EX z::real. ALL x::real. P x --> x < z))"
+  by (import real SETOK_LE_LT)
+
+lemma REAL_SUP_LE: "Ex P & (EX z. ALL x. P x --> x <= z)
+==> (EX x. P x & y < x) = (y < real.sup P)"
+  by (import real REAL_SUP_LE)
+
+lemma REAL_SUP_UBOUND_LE: "[| Ex P & (EX z. ALL x. P x --> x <= z); P y |] ==> y <= real.sup P"
+  by (import real REAL_SUP_UBOUND_LE)
+
+consts
+  sumc :: "nat => nat => (nat => real) => real" 
+
+specification (sumc) sumc: "(ALL n f. sumc n 0 f = 0) &
+(ALL n m f. sumc n (Suc m) f = sumc n m f + f (n + m))"
+  by (import real sumc)
+
+consts
+  sum :: "nat * nat => (nat => real) => real" 
+
+defs
+  sum_def: "real.sum == %(x, y). sumc x y"
+
+lemma SUM_DEF: "real.sum (m, n) f = sumc m n f"
+  by (import real SUM_DEF)
+
+lemma sum: "real.sum (xa, 0) x = 0 &
+real.sum (xa, Suc xb) x = real.sum (xa, xb) x + x (xa + xb)"
+  by (import real sum)
+
+lemma SUM_TWO: "real.sum (0, n) f + real.sum (n, p) f = real.sum (0, n + p) f"
+  by (import real SUM_TWO)
+
+lemma SUM_DIFF: "real.sum (m, n) f = real.sum (0, m + n) f - real.sum (0, m) f"
+  by (import real SUM_DIFF)
+
+lemma ABS_SUM: "abs (real.sum (m, n) f) <= real.sum (m, n) (%n. abs (f n))"
+  by (import real ABS_SUM)
+
+lemma SUM_LE: "(!!r. m <= r & r < n + m ==> f r <= g r)
+==> real.sum (m, n) f <= real.sum (m, n) g"
+  by (import real SUM_LE)
+
+lemma SUM_EQ: "(!!r. m <= r & r < n + m ==> f r = g r)
+==> real.sum (m, n) f = real.sum (m, n) g"
+  by (import real SUM_EQ)
+
+lemma SUM_POS: "(!!n. 0 <= f n) ==> 0 <= real.sum (m, n) f"
+  by (import real SUM_POS)
+
+lemma SUM_POS_GEN: "(!!n. m <= n ==> 0 <= f n) ==> 0 <= real.sum (m, n) f"
+  by (import real SUM_POS_GEN)
+
+lemma SUM_ABS: "abs (real.sum (m, x) (%m. abs (f m))) = real.sum (m, x) (%m. abs (f m))"
+  by (import real SUM_ABS)
+
+lemma SUM_ABS_LE: "abs (real.sum (m, n) f) <= real.sum (m, n) (%n. abs (f n))"
+  by (import real SUM_ABS_LE)
+
+lemma SUM_ZERO: "[| !!n. N <= n ==> f n = 0; N <= m |] ==> real.sum (m, n) f = 0"
+  by (import real SUM_ZERO)
+
+lemma SUM_ADD: "real.sum (m, n) (%n. f n + g n) = real.sum (m, n) f + real.sum (m, n) g"
+  by (import real SUM_ADD)
+
+lemma SUM_CMUL: "real.sum (m, n) (%n. c * f n) = c * real.sum (m, n) f"
+  by (import real SUM_CMUL)
+
+lemma SUM_NEG: "real.sum (n, d) (%n. - f n) = - real.sum (n, d) f"
+  by (import real SUM_NEG)
+
+lemma SUM_SUB: "real.sum (m, n) (%x. f x - g x) = real.sum (m, n) f - real.sum (m, n) g"
+  by (import real SUM_SUB)
+
+lemma SUM_SUBST: "(!!p. m <= p & p < m + n ==> f p = g p)
+==> real.sum (m, n) f = real.sum (m, n) g"
+  by (import real SUM_SUBST)
+
+lemma SUM_NSUB: "real.sum (0, n) f - real n * c = real.sum (0, n) (%p. f p - c)"
+  by (import real SUM_NSUB)
+
+lemma SUM_BOUND: "(!!p. m <= p & p < m + n ==> f p <= k) ==> real.sum (m, n) f <= real n * k"
+  by (import real SUM_BOUND)
+
+lemma SUM_GROUP: "real.sum (0, n) (%m. real.sum (m * k, k) f) = real.sum (0, n * k) f"
+  by (import real SUM_GROUP)
+
+lemma SUM_1: "real.sum (n, 1) f = f n"
+  by (import real SUM_1)
+
+lemma SUM_2: "real.sum (n, 2) f = f n + f (n + 1)"
+  by (import real SUM_2)
+
+lemma SUM_OFFSET: "real.sum (0, n) (%m. f (m + k)) = real.sum (0, n + k) f - real.sum (0, k) f"
+  by (import real SUM_OFFSET)
+
+lemma SUM_REINDEX: "real.sum (m + k, n) f = real.sum (m, n) (%r. f (r + k))"
+  by (import real SUM_REINDEX)
+
+lemma SUM_0: "real.sum (m, n) (%r. 0) = 0"
+  by (import real SUM_0)
+
+lemma SUM_PERMUTE_0: "(!!y. y < n ==> EX! x. x < n & p x = y)
+==> real.sum (0, n) (%n. f (p n)) = real.sum (0, n) f"
+  by (import real SUM_PERMUTE_0)
+
+lemma SUM_CANCEL: "real.sum (n, d) (%n. f (Suc n) - f n) = f (n + d) - f n"
+  by (import real SUM_CANCEL)
+
+lemma REAL_LE_RNEG: "((x::real) <= - (y::real)) = (x + y <= (0::real))"
+  by (import real REAL_LE_RNEG)
+
+lemma REAL_EQ_RDIV_EQ: "(0::real) < (xb::real) ==> ((x::real) = (xa::real) / xb) = (x * xb = xa)"
+  by (import real REAL_EQ_RDIV_EQ)
+
+lemma REAL_EQ_LDIV_EQ: "(0::real) < (xb::real) ==> ((x::real) / xb = (xa::real)) = (x = xa * xb)"
+  by (import real REAL_EQ_LDIV_EQ)
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" topology
+
+definition
+  re_Union :: "(('a => bool) => bool) => 'a => bool"  where
+  "re_Union == %P x. EX s. P s & s x"
+
+lemma re_Union: "re_Union P = (%x. EX s. P s & s x)"
+  by (import topology re_Union)
+
+definition
+  re_union :: "('a => bool) => ('a => bool) => 'a => bool"  where
+  "re_union == %P Q x. P x | Q x"
+
+lemma re_union: "re_union P Q = (%x. P x | Q x)"
+  by (import topology re_union)
+
+definition
+  re_intersect :: "('a => bool) => ('a => bool) => 'a => bool"  where
+  "re_intersect == %P Q x. P x & Q x"
+
+lemma re_intersect: "re_intersect P Q = (%x. P x & Q x)"
+  by (import topology re_intersect)
+
+definition
+  re_null :: "'a => bool"  where
+  "re_null == %x. False"
+
+lemma re_null: "re_null = (%x. False)"
+  by (import topology re_null)
+
+definition
+  re_universe :: "'a => bool"  where
+  "re_universe == %x. True"
+
+lemma re_universe: "re_universe = (%x. True)"
+  by (import topology re_universe)
+
+definition
+  re_subset :: "('a => bool) => ('a => bool) => bool"  where
+  "re_subset == %P Q. ALL x. P x --> Q x"
+
+lemma re_subset: "re_subset P Q = (ALL x. P x --> Q x)"
+  by (import topology re_subset)
+
+definition
+  re_compl :: "('a => bool) => 'a => bool"  where
+  "re_compl == %P x. ~ P x"
+
+lemma re_compl: "re_compl P = (%x. ~ P x)"
+  by (import topology re_compl)
+
+lemma SUBSET_REFL: "re_subset P P"
+  by (import topology SUBSET_REFL)
+
+lemma COMPL_MEM: "P x = (~ re_compl P x)"
+  by (import topology COMPL_MEM)
+
+lemma SUBSET_ANTISYM: "(re_subset P Q & re_subset Q P) = (P = Q)"
+  by (import topology SUBSET_ANTISYM)
+
+lemma SUBSET_TRANS: "re_subset P Q & re_subset Q R ==> re_subset P R"
+  by (import topology SUBSET_TRANS)
+
+definition
+  istopology :: "(('a => bool) => bool) => bool"  where
+  "istopology ==
+%L. L re_null &
+    L re_universe &
+    (ALL a b. L a & L b --> L (re_intersect a b)) &
+    (ALL P. re_subset P L --> L (re_Union P))"
+
+lemma istopology: "istopology L =
+(L re_null &
+ L re_universe &
+ (ALL a b. L a & L b --> L (re_intersect a b)) &
+ (ALL P. re_subset P L --> L (re_Union P)))"
+  by (import topology istopology)
+
+typedef (open) ('a) topology = "Collect istopology::(('a::type => bool) => bool) set"
+  by (rule typedef_helper,import topology topology_TY_DEF)
+
+lemmas topology_TY_DEF = typedef_hol2hol4 [OF type_definition_topology]
+
+consts
+  topology :: "(('a => bool) => bool) => 'a topology" 
+  "open" :: "'a topology => ('a => bool) => bool" 
+
+specification ("open" topology) topology_tybij: "(ALL a::'a topology. topology (topology.open a) = a) &
+(ALL r::('a => bool) => bool.
+    istopology r = (topology.open (topology r) = r))"
+  by (import topology topology_tybij)
+
+lemma TOPOLOGY: "topology.open L re_null &
+topology.open L re_universe &
+(ALL a b.
+    topology.open L a & topology.open L b -->
+    topology.open L (re_intersect a b)) &
+(ALL P. re_subset P (topology.open L) --> topology.open L (re_Union P))"
+  by (import topology TOPOLOGY)
+
+lemma TOPOLOGY_UNION: "re_subset xa (topology.open x) ==> topology.open x (re_Union xa)"
+  by (import topology TOPOLOGY_UNION)
+
+definition
+  neigh :: "'a topology => ('a => bool) * 'a => bool"  where
+  "neigh == %tp (N, x). EX P. topology.open tp P & re_subset P N & P x"
+
+lemma neigh: "neigh (tp::'a::type topology) (N::'a::type => bool, x::'a::type) =
+(EX P::'a::type => bool. topology.open tp P & re_subset P N & P x)"
+  by (import topology neigh)
+
+lemma OPEN_OWN_NEIGH: "topology.open (tp::'a::type topology) (S'::'a::type => bool) &
+S' (x::'a::type)
+==> neigh tp (S', x)"
+  by (import topology OPEN_OWN_NEIGH)
+
+lemma OPEN_UNOPEN: "topology.open (tp::'a::type topology) (S'::'a::type => bool) =
+(re_Union (%P::'a::type => bool. topology.open tp P & re_subset P S') = S')"
+  by (import topology OPEN_UNOPEN)
+
+lemma OPEN_SUBOPEN: "topology.open (tp::'a::type topology) (S'::'a::type => bool) =
+(ALL x::'a::type.
+    S' x -->
+    (EX P::'a::type => bool. P x & topology.open tp P & re_subset P S'))"
+  by (import topology OPEN_SUBOPEN)
+
+lemma OPEN_NEIGH: "topology.open (tp::'a::type topology) (S'::'a::type => bool) =
+(ALL x::'a::type.
+    S' x --> (EX N::'a::type => bool. neigh tp (N, x) & re_subset N S'))"
+  by (import topology OPEN_NEIGH)
+
+consts
+  closed :: "'a topology => ('a => bool) => bool" 
+
+defs
+  closed_def: "topology.closed == %L S'. topology.open L (re_compl S')"
+
+lemma closed: "topology.closed L S' = topology.open L (re_compl S')"
+  by (import topology closed)
+
+definition
+  limpt :: "'a topology => 'a => ('a => bool) => bool"  where
+  "limpt == %tp x S'. ALL N. neigh tp (N, x) --> (EX y. x ~= y & S' y & N y)"
+
+lemma limpt: "limpt (tp::'a::type topology) (x::'a::type) (S'::'a::type => bool) =
+(ALL N::'a::type => bool.
+    neigh tp (N, x) --> (EX y::'a::type. x ~= y & S' y & N y))"
+  by (import topology limpt)
+
+lemma CLOSED_LIMPT: "topology.closed (tp::'a::type topology) (S'::'a::type => bool) =
+(ALL x::'a::type. limpt tp x S' --> S' x)"
+  by (import topology CLOSED_LIMPT)
+
+definition
+  ismet :: "('a * 'a => real) => bool"  where
+  "ismet ==
+%m. (ALL x y. (m (x, y) = 0) = (x = y)) &
+    (ALL x y z. m (y, z) <= m (x, y) + m (x, z))"
+
+lemma ismet: "ismet m =
+((ALL x y. (m (x, y) = 0) = (x = y)) &
+ (ALL x y z. m (y, z) <= m (x, y) + m (x, z)))"
+  by (import topology ismet)
+
+typedef (open) ('a) metric = "Collect ismet :: ('a::type * 'a::type => real) set"
+  by (rule typedef_helper,import topology metric_TY_DEF)
+
+lemmas metric_TY_DEF = typedef_hol2hol4 [OF type_definition_metric]
+
+consts
+  metric :: "('a * 'a => real) => 'a metric" 
+  dist :: "'a metric => 'a * 'a => real" 
+
+specification (dist metric) metric_tybij: "(ALL a::'a metric. metric (topology.dist a) = a) &
+(ALL r::'a * 'a => real. ismet r = (topology.dist (metric r) = r))"
+  by (import topology metric_tybij)
+
+lemma METRIC_ISMET: "ismet (topology.dist m)"
+  by (import topology METRIC_ISMET)
+
+lemma METRIC_ZERO: "(topology.dist m (x, y) = 0) = (x = y)"
+  by (import topology METRIC_ZERO)
+
+lemma METRIC_SAME: "topology.dist m (x, x) = 0"
+  by (import topology METRIC_SAME)
+
+lemma METRIC_POS: "0 <= topology.dist m (x, y)"
+  by (import topology METRIC_POS)
+
+lemma METRIC_SYM: "topology.dist m (x, y) = topology.dist m (y, x)"
+  by (import topology METRIC_SYM)
+
+lemma METRIC_TRIANGLE: "topology.dist m (x, z) <= topology.dist m (x, y) + topology.dist m (y, z)"
+  by (import topology METRIC_TRIANGLE)
+
+lemma METRIC_NZ: "x ~= y ==> 0 < topology.dist m (x, y)"
+  by (import topology METRIC_NZ)
+
+definition
+  mtop :: "'a metric => 'a topology"  where
+  "mtop ==
+%m. topology
+     (%S'. ALL x.
+              S' x --> (EX e>0. ALL y. topology.dist m (x, y) < e --> S' y))"
+
+lemma mtop: "mtop m =
+topology
+ (%S'. ALL x. S' x --> (EX e>0. ALL y. topology.dist m (x, y) < e --> S' y))"
+  by (import topology mtop)
+
+lemma mtop_istopology: "istopology
+ (%S'. ALL x. S' x --> (EX e>0. ALL y. topology.dist m (x, y) < e --> S' y))"
+  by (import topology mtop_istopology)
+
+lemma MTOP_OPEN: "topology.open (mtop x) S' =
+(ALL xa. S' xa --> (EX e>0. ALL y. topology.dist x (xa, y) < e --> S' y))"
+  by (import topology MTOP_OPEN)
+
+definition
+  B :: "'a metric => 'a * real => 'a => bool"  where
+  "B == %m (x, e) y. topology.dist m (x, y) < e"
+
+lemma ball: "B m (x, e) = (%y. topology.dist m (x, y) < e)"
+  by (import topology ball)
+
+lemma BALL_OPEN: "0 < e ==> topology.open (mtop m) (B m (x, e))"
+  by (import topology BALL_OPEN)
+
+lemma BALL_NEIGH: "0 < e ==> neigh (mtop m) (B m (x, e), x)"
+  by (import topology BALL_NEIGH)
+
+lemma MTOP_LIMPT: "limpt (mtop m) x S' =
+(ALL e>0. EX y. x ~= y & S' y & topology.dist m (x, y) < e)"
+  by (import topology MTOP_LIMPT)
+
+lemma ISMET_R1: "ismet (%(x, y). abs (y - x))"
+  by (import topology ISMET_R1)
+
+definition
+  mr1 :: "real metric"  where
+  "mr1 == metric (%(x, y). abs (y - x))"
+
+lemma mr1: "mr1 = metric (%(x, y). abs (y - x))"
+  by (import topology mr1)
+
+lemma MR1_DEF: "topology.dist mr1 (x, y) = abs (y - x)"
+  by (import topology MR1_DEF)
+
+lemma MR1_ADD: "topology.dist mr1 (x, x + d) = abs d"
+  by (import topology MR1_ADD)
+
+lemma MR1_SUB: "topology.dist mr1 (x, x - d) = abs d"
+  by (import topology MR1_SUB)
+
+lemma MR1_ADD_POS: "0 <= d ==> topology.dist mr1 (x, x + d) = d"
+  by (import topology MR1_ADD_POS)
+
+lemma MR1_SUB_LE: "0 <= d ==> topology.dist mr1 (x, x - d) = d"
+  by (import topology MR1_SUB_LE)
+
+lemma MR1_ADD_LT: "0 < d ==> topology.dist mr1 (x, x + d) = d"
+  by (import topology MR1_ADD_LT)
+
+lemma MR1_SUB_LT: "0 < d ==> topology.dist mr1 (x, x - d) = d"
+  by (import topology MR1_SUB_LT)
+
+lemma MR1_BETWEEN1: "x < z & topology.dist mr1 (x, y) < z - x ==> y < z"
+  by (import topology MR1_BETWEEN1)
+
+lemma MR1_LIMPT: "limpt (mtop mr1) x re_universe"
+  by (import topology MR1_LIMPT)
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" nets
+
+definition
+  dorder :: "('a => 'a => bool) => bool"  where
+  "dorder ==
+%g. ALL x y.
+       g x x & g y y --> (EX z. g z z & (ALL w. g w z --> g w x & g w y))"
+
+lemma dorder: "dorder g =
+(ALL x y.
+    g x x & g y y --> (EX z. g z z & (ALL w. g w z --> g w x & g w y)))"
+  by (import nets dorder)
+
+definition
+  tends :: "('b => 'a) => 'a => 'a topology * ('b => 'b => bool) => bool"  where
+  "tends ==
+%(s::'b => 'a) (l::'a) (tp::'a topology, g::'b => 'b => bool).
+   ALL N::'a => bool.
+      neigh tp (N, l) -->
+      (EX n::'b. g n n & (ALL m::'b. g m n --> N (s m)))"
+
+lemma tends: "tends (s::'b::type => 'a::type) (l::'a::type)
+ (tp::'a::type topology, g::'b::type => 'b::type => bool) =
+(ALL N::'a::type => bool.
+    neigh tp (N, l) -->
+    (EX n::'b::type. g n n & (ALL m::'b::type. g m n --> N (s m))))"
+  by (import nets tends)
+
+definition
+  bounded :: "'a metric * ('b => 'b => bool) => ('b => 'a) => bool"  where
+  "bounded ==
+%(m, g) f. EX k x N. g N N & (ALL n. g n N --> topology.dist m (f n, x) < k)"
+
+lemma bounded: "bounded (m, g) f =
+(EX k x N. g N N & (ALL n. g n N --> topology.dist m (f n, x) < k))"
+  by (import nets bounded)
+
+consts
+  tendsto :: "'a metric * 'a => 'a => 'a => bool" 
+
+defs
+  tendsto_def: "nets.tendsto ==
+%(m, x) y z.
+   0 < topology.dist m (x, y) &
+   topology.dist m (x, y) <= topology.dist m (x, z)"
+
+lemma tendsto: "nets.tendsto (m, x) y z =
+(0 < topology.dist m (x, y) &
+ topology.dist m (x, y) <= topology.dist m (x, z))"
+  by (import nets tendsto)
+
+lemma DORDER_LEMMA: "[| dorder g;
+   (EX n. g n n & (ALL m. g m n --> P m)) &
+   (EX n. g n n & (ALL m. g m n --> Q m)) |]
+==> EX n. g n n & (ALL m. g m n --> P m & Q m)"
+  by (import nets DORDER_LEMMA)
+
+lemma DORDER_NGE: "dorder nat_ge"
+  by (import nets DORDER_NGE)
+
+lemma DORDER_TENDSTO: "dorder (nets.tendsto (m, x))"
+  by (import nets DORDER_TENDSTO)
+
+lemma MTOP_TENDS: "tends (x::'b => 'a) (x0::'a) (mtop (d::'a metric), g::'b => 'b => bool) =
+(ALL e>0::real.
+    EX n::'b. g n n & (ALL m::'b. g m n --> topology.dist d (x m, x0) < e))"
+  by (import nets MTOP_TENDS)
+
+lemma MTOP_TENDS_UNIQ: "[| dorder (g::'b => 'b => bool);
+   tends (x::'b => 'a) (x0::'a) (mtop (d::'a metric), g) &
+   tends x (x1::'a) (mtop d, g) |]
+==> x0 = x1"
+  by (import nets MTOP_TENDS_UNIQ)
+
+lemma SEQ_TENDS: "tends x x0 (mtop d, nat_ge) =
+(ALL xa>0. EX xb. ALL xc>=xb. topology.dist d (x xc, x0) < xa)"
+  by (import nets SEQ_TENDS)
+
+lemma LIM_TENDS: "limpt (mtop m1) x0 re_universe
+==> tends f y0 (mtop m2, nets.tendsto (m1, x0)) =
+    (ALL e>0.
+        EX d>0.
+           ALL x.
+              0 < topology.dist m1 (x, x0) &
+              topology.dist m1 (x, x0) <= d -->
+              topology.dist m2 (f x, y0) < e)"
+  by (import nets LIM_TENDS)
+
+lemma LIM_TENDS2: "limpt (mtop m1) x0 re_universe
+==> tends f y0 (mtop m2, nets.tendsto (m1, x0)) =
+    (ALL e>0.
+        EX d>0.
+           ALL x.
+              0 < topology.dist m1 (x, x0) &
+              topology.dist m1 (x, x0) < d -->
+              topology.dist m2 (f x, y0) < e)"
+  by (import nets LIM_TENDS2)
+
+lemma MR1_BOUNDED: "bounded (mr1, g) f = (EX k N. g N N & (ALL n. g n N --> abs (f n) < k))"
+  by (import nets MR1_BOUNDED)
+
+lemma NET_NULL: "tends x x0 (mtop mr1, g) = tends (%n. x n - x0) 0 (mtop mr1, g)"
+  by (import nets NET_NULL)
+
+lemma NET_CONV_BOUNDED: "tends x x0 (mtop mr1, g) ==> bounded (mr1, g) x"
+  by (import nets NET_CONV_BOUNDED)
+
+lemma NET_CONV_NZ: "tends x x0 (mtop mr1, g) & x0 ~= 0
+==> EX N. g N N & (ALL n. g n N --> x n ~= 0)"
+  by (import nets NET_CONV_NZ)
+
+lemma NET_CONV_IBOUNDED: "tends x x0 (mtop mr1, g) & x0 ~= 0 ==> bounded (mr1, g) (%n. inverse (x n))"
+  by (import nets NET_CONV_IBOUNDED)
+
+lemma NET_NULL_ADD: "[| dorder g; tends x 0 (mtop mr1, g) & tends y 0 (mtop mr1, g) |]
+==> tends (%n. x n + y n) 0 (mtop mr1, g)"
+  by (import nets NET_NULL_ADD)
+
+lemma NET_NULL_MUL: "[| dorder g; bounded (mr1, g) x & tends y 0 (mtop mr1, g) |]
+==> tends (%n. x n * y n) 0 (mtop mr1, g)"
+  by (import nets NET_NULL_MUL)
+
+lemma NET_NULL_CMUL: "tends x 0 (mtop mr1, g) ==> tends (%n. k * x n) 0 (mtop mr1, g)"
+  by (import nets NET_NULL_CMUL)
+
+lemma NET_ADD: "[| dorder g; tends x x0 (mtop mr1, g) & tends y y0 (mtop mr1, g) |]
+==> tends (%n. x n + y n) (x0 + y0) (mtop mr1, g)"
+  by (import nets NET_ADD)
+
+lemma NET_NEG: "dorder g
+==> tends x x0 (mtop mr1, g) = tends (%n. - x n) (- x0) (mtop mr1, g)"
+  by (import nets NET_NEG)
+
+lemma NET_SUB: "[| dorder g; tends x x0 (mtop mr1, g) & tends y y0 (mtop mr1, g) |]
+==> tends (%xa. x xa - y xa) (x0 - y0) (mtop mr1, g)"
+  by (import nets NET_SUB)
+
+lemma NET_MUL: "[| dorder g; tends x x0 (mtop mr1, g) & tends y y0 (mtop mr1, g) |]
+==> tends (%n. x n * y n) (x0 * y0) (mtop mr1, g)"
+  by (import nets NET_MUL)
+
+lemma NET_INV: "[| dorder g; tends x x0 (mtop mr1, g) & x0 ~= 0 |]
+==> tends (%n. inverse (x n)) (inverse x0) (mtop mr1, g)"
+  by (import nets NET_INV)
+
+lemma NET_DIV: "[| dorder g;
+   tends x x0 (mtop mr1, g) & tends y y0 (mtop mr1, g) & y0 ~= 0 |]
+==> tends (%xa. x xa / y xa) (x0 / y0) (mtop mr1, g)"
+  by (import nets NET_DIV)
+
+lemma NET_ABS: "tends x x0 (mtop mr1, g) ==> tends (%n. abs (x n)) (abs x0) (mtop mr1, g)"
+  by (import nets NET_ABS)
+
+lemma NET_LE: "[| dorder g;
+   tends x x0 (mtop mr1, g) &
+   tends y y0 (mtop mr1, g) &
+   (EX N. g N N & (ALL n. g n N --> x n <= y n)) |]
+==> x0 <= y0"
+  by (import nets NET_LE)
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" seq
+
+consts
+  "hol4-->" :: "(nat => real) => real => bool" ("hol4-->")
+
+defs
+  "hol4-->_def": "hol4--> == %x x0. tends x x0 (mtop mr1, nat_ge)"
+
+lemma tends_num_real: "hol4--> x x0 = tends x x0 (mtop mr1, nat_ge)"
+  by (import seq tends_num_real)
+
+lemma SEQ: "hol4--> x x0 = (ALL e>0. EX N. ALL n>=N. abs (x n - x0) < e)"
+  by (import seq SEQ)
+
+lemma SEQ_CONST: "hol4--> (%x. k) k"
+  by (import seq SEQ_CONST)
+
+lemma SEQ_ADD: "hol4--> x x0 & hol4--> y y0 ==> hol4--> (%n. x n + y n) (x0 + y0)"
+  by (import seq SEQ_ADD)
+
+lemma SEQ_MUL: "hol4--> x x0 & hol4--> y y0 ==> hol4--> (%n. x n * y n) (x0 * y0)"
+  by (import seq SEQ_MUL)
+
+lemma SEQ_NEG: "hol4--> x x0 = hol4--> (%n. - x n) (- x0)"
+  by (import seq SEQ_NEG)
+
+lemma SEQ_INV: "hol4--> x x0 & x0 ~= 0 ==> hol4--> (%n. inverse (x n)) (inverse x0)"
+  by (import seq SEQ_INV)
+
+lemma SEQ_SUB: "hol4--> x x0 & hol4--> y y0 ==> hol4--> (%n. x n - y n) (x0 - y0)"
+  by (import seq SEQ_SUB)
+
+lemma SEQ_DIV: "hol4--> x x0 & hol4--> y y0 & y0 ~= 0 ==> hol4--> (%n. x n / y n) (x0 / y0)"
+  by (import seq SEQ_DIV)
+
+lemma SEQ_UNIQ: "hol4--> x x1 & hol4--> x x2 ==> x1 = x2"
+  by (import seq SEQ_UNIQ)
+
+consts
+  convergent :: "(nat => real) => bool" 
+
+defs
+  convergent_def: "seq.convergent == %f. Ex (hol4--> f)"
+
+lemma convergent: "seq.convergent f = Ex (hol4--> f)"
+  by (import seq convergent)
+
+definition
+  cauchy :: "(nat => real) => bool"  where
+  "cauchy ==
+%f. ALL e>0. EX N. ALL m n. N <= m & N <= n --> abs (f m - f n) < e"
+
+lemma cauchy: "cauchy f = (ALL e>0. EX N. ALL m n. N <= m & N <= n --> abs (f m - f n) < e)"
+  by (import seq cauchy)
+
+consts
+  lim :: "(nat => real) => real" 
+
+defs
+  lim_def: "seq.lim == %f. Eps (hol4--> f)"
+
+lemma lim: "seq.lim f = Eps (hol4--> f)"
+  by (import seq lim)
+
+lemma SEQ_LIM: "seq.convergent f = hol4--> f (seq.lim f)"
+  by (import seq SEQ_LIM)
+
+consts
+  subseq :: "(nat => nat) => bool" 
+
+defs
+  subseq_def: "seq.subseq == %f. ALL m n. m < n --> f m < f n"
+
+lemma subseq: "seq.subseq f = (ALL m n. m < n --> f m < f n)"
+  by (import seq subseq)
+
+lemma SUBSEQ_SUC: "seq.subseq f = (ALL n. f n < f (Suc n))"
+  by (import seq SUBSEQ_SUC)
+
+consts
+  mono :: "(nat => real) => bool" 
+
+defs
+  mono_def: "seq.mono ==
+%f. (ALL m n. m <= n --> f m <= f n) | (ALL m n. m <= n --> f n <= f m)"
+
+lemma mono: "seq.mono f =
+((ALL m n. m <= n --> f m <= f n) | (ALL m n. m <= n --> f n <= f m))"
+  by (import seq mono)
+
+lemma MONO_SUC: "seq.mono f = ((ALL x. f x <= f (Suc x)) | (ALL n. f (Suc n) <= f n))"
+  by (import seq MONO_SUC)
+
+lemma MAX_LEMMA: "EX k::real. ALL n<N::nat. abs ((s::nat => real) n) < k"
+  by (import seq MAX_LEMMA)
+
+lemma SEQ_BOUNDED: "bounded (mr1, nat_ge) s = (EX k. ALL n. abs (s n) < k)"
+  by (import seq SEQ_BOUNDED)
+
+lemma SEQ_BOUNDED_2: "(!!n. k <= f n & f n <= k') ==> bounded (mr1, nat_ge) f"
+  by (import seq SEQ_BOUNDED_2)
+
+lemma SEQ_CBOUNDED: "cauchy f ==> bounded (mr1, nat_ge) f"
+  by (import seq SEQ_CBOUNDED)
+
+lemma SEQ_ICONV: "bounded (mr1, nat_ge) f & (ALL m n. n <= m --> f n <= f m)
+==> seq.convergent f"
+  by (import seq SEQ_ICONV)
+
+lemma SEQ_NEG_CONV: "seq.convergent f = seq.convergent (%n. - f n)"
+  by (import seq SEQ_NEG_CONV)
+
+lemma SEQ_NEG_BOUNDED: "bounded (mr1, nat_ge) (%n. - f n) = bounded (mr1, nat_ge) f"
+  by (import seq SEQ_NEG_BOUNDED)
+
+lemma SEQ_BCONV: "bounded (mr1, nat_ge) f & seq.mono f ==> seq.convergent f"
+  by (import seq SEQ_BCONV)
+
+lemma SEQ_MONOSUB: "EX f. seq.subseq f & seq.mono (%n. s (f n))"
+  by (import seq SEQ_MONOSUB)
+
+lemma SEQ_SBOUNDED: "bounded (mr1, nat_ge) s ==> bounded (mr1, nat_ge) (%n. s (f n))"
+  by (import seq SEQ_SBOUNDED)
+
+lemma SEQ_SUBLE: "seq.subseq f ==> n <= f n"
+  by (import seq SEQ_SUBLE)
+
+lemma SEQ_DIRECT: "seq.subseq f ==> EX x>=N1. N2 <= f x"
+  by (import seq SEQ_DIRECT)
+
+lemma SEQ_CAUCHY: "cauchy f = seq.convergent f"
+  by (import seq SEQ_CAUCHY)
+
+lemma SEQ_LE: "hol4--> f l & hol4--> g m & (EX x. ALL xa>=x. f xa <= g xa) ==> l <= m"
+  by (import seq SEQ_LE)
+
+lemma SEQ_SUC: "hol4--> f l = hol4--> (%n. f (Suc n)) l"
+  by (import seq SEQ_SUC)
+
+lemma SEQ_ABS: "hol4--> (%n. abs (f n)) 0 = hol4--> f 0"
+  by (import seq SEQ_ABS)
+
+lemma SEQ_ABS_IMP: "hol4--> f l ==> hol4--> (%n. abs (f n)) (abs l)"
+  by (import seq SEQ_ABS_IMP)
+
+lemma SEQ_INV0: "(!!y. EX N. ALL n>=N. y < f n) ==> hol4--> (%n. inverse (f n)) 0"
+  by (import seq SEQ_INV0)
+
+lemma SEQ_POWER_ABS: "abs c < 1 ==> hol4--> (op ^ (abs c)) 0"
+  by (import seq SEQ_POWER_ABS)
+
+lemma SEQ_POWER: "abs c < 1 ==> hol4--> (op ^ c) 0"
+  by (import seq SEQ_POWER)
+
+lemma NEST_LEMMA: "(ALL n. f n <= f (Suc n)) & (ALL n. g (Suc n) <= g n) & (ALL n. f n <= g n)
+==> EX l m.
+       l <= m &
+       ((ALL n. f n <= l) & hol4--> f l) & (ALL n. m <= g n) & hol4--> g m"
+  by (import seq NEST_LEMMA)
+
+lemma NEST_LEMMA_UNIQ: "(ALL n. f n <= f (Suc n)) &
+(ALL n. g (Suc n) <= g n) & (ALL n. f n <= g n) & hol4--> (%n. f n - g n) 0
+==> EX x. ((ALL n. f n <= x) & hol4--> f x) &
+          (ALL n. x <= g n) & hol4--> g x"
+  by (import seq NEST_LEMMA_UNIQ)
+
+consts
+  sums :: "(nat => real) => real => bool" 
+
+defs
+  sums_def: "seq.sums == %f. hol4--> (%n. real.sum (0, n) f)"
+
+lemma sums: "seq.sums f s = hol4--> (%n. real.sum (0, n) f) s"
+  by (import seq sums)
+
+consts
+  summable :: "(nat => real) => bool" 
+
+defs
+  summable_def: "seq.summable == %f. Ex (seq.sums f)"
+
+lemma summable: "seq.summable f = Ex (seq.sums f)"
+  by (import seq summable)
+
+consts
+  suminf :: "(nat => real) => real" 
+
+defs
+  suminf_def: "seq.suminf == %f. Eps (seq.sums f)"
+
+lemma suminf: "seq.suminf f = Eps (seq.sums f)"
+  by (import seq suminf)
+
+lemma SUM_SUMMABLE: "seq.sums f l ==> seq.summable f"
+  by (import seq SUM_SUMMABLE)
+
+lemma SUMMABLE_SUM: "seq.summable f ==> seq.sums f (seq.suminf f)"
+  by (import seq SUMMABLE_SUM)
+
+lemma SUM_UNIQ: "seq.sums f x ==> x = seq.suminf f"
+  by (import seq SUM_UNIQ)
+
+lemma SER_0: "(!!m. n <= m ==> f m = 0) ==> seq.sums f (real.sum (0, n) f)"
+  by (import seq SER_0)
+
+lemma SER_POS_LE: "seq.summable f & (ALL m>=n. 0 <= f m) ==> real.sum (0, n) f <= seq.suminf f"
+  by (import seq SER_POS_LE)
+
+lemma SER_POS_LT: "seq.summable f & (ALL m>=n. 0 < f m) ==> real.sum (0, n) f < seq.suminf f"
+  by (import seq SER_POS_LT)
+
+lemma SER_GROUP: "seq.summable f & 0 < k
+==> seq.sums (%n. real.sum (n * k, k) f) (seq.suminf f)"
+  by (import seq SER_GROUP)
+
+lemma SER_PAIR: "seq.summable f ==> seq.sums (%n. real.sum (2 * n, 2) f) (seq.suminf f)"
+  by (import seq SER_PAIR)
+
+lemma SER_OFFSET: "seq.summable f
+==> seq.sums (%n. f (n + k)) (seq.suminf f - real.sum (0, k) f)"
+  by (import seq SER_OFFSET)
+
+lemma SER_POS_LT_PAIR: "seq.summable f & (ALL d. 0 < f (n + 2 * d) + f (n + (2 * d + 1)))
+==> real.sum (0, n) f < seq.suminf f"
+  by (import seq SER_POS_LT_PAIR)
+
+lemma SER_ADD: "seq.sums x x0 & seq.sums y y0 ==> seq.sums (%n. x n + y n) (x0 + y0)"
+  by (import seq SER_ADD)
+
+lemma SER_CMUL: "seq.sums x x0 ==> seq.sums (%n. c * x n) (c * x0)"
+  by (import seq SER_CMUL)
+
+lemma SER_NEG: "seq.sums x x0 ==> seq.sums (%xa. - x xa) (- x0)"
+  by (import seq SER_NEG)
+
+lemma SER_SUB: "seq.sums x x0 & seq.sums y y0 ==> seq.sums (%xa. x xa - y xa) (x0 - y0)"
+  by (import seq SER_SUB)
+
+lemma SER_CDIV: "seq.sums x x0 ==> seq.sums (%xa. x xa / c) (x0 / c)"
+  by (import seq SER_CDIV)
+
+lemma SER_CAUCHY: "seq.summable f =
+(ALL e>0. EX N. ALL m n. N <= m --> abs (real.sum (m, n) f) < e)"
+  by (import seq SER_CAUCHY)
+
+lemma SER_ZERO: "seq.summable f ==> hol4--> f 0"
+  by (import seq SER_ZERO)
+
+lemma SER_COMPAR: "(EX x. ALL xa>=x. abs (f xa) <= g xa) & seq.summable g ==> seq.summable f"
+  by (import seq SER_COMPAR)
+
+lemma SER_COMPARA: "(EX x. ALL xa>=x. abs (f xa) <= g xa) & seq.summable g
+==> seq.summable (%k. abs (f k))"
+  by (import seq SER_COMPARA)
+
+lemma SER_LE: "(ALL n. f n <= g n) & seq.summable f & seq.summable g
+==> seq.suminf f <= seq.suminf g"
+  by (import seq SER_LE)
+
+lemma SER_LE2: "(ALL n. abs (f n) <= g n) & seq.summable g
+==> seq.summable f & seq.suminf f <= seq.suminf g"
+  by (import seq SER_LE2)
+
+lemma SER_ACONV: "seq.summable (%n. abs (f n)) ==> seq.summable f"
+  by (import seq SER_ACONV)
+
+lemma SER_ABS: "seq.summable (%n. abs (f n))
+==> abs (seq.suminf f) <= seq.suminf (%n. abs (f n))"
+  by (import seq SER_ABS)
+
+lemma GP_FINITE: "x ~= 1 ==> real.sum (0, n) (op ^ x) = (x ^ n - 1) / (x - 1)"
+  by (import seq GP_FINITE)
+
+lemma GP: "abs x < 1 ==> seq.sums (op ^ x) (inverse (1 - x))"
+  by (import seq GP)
+
+lemma SER_RATIO: "c < 1 & (ALL n>=N. abs (f (Suc n)) <= c * abs (f n)) ==> seq.summable f"
+  by (import seq SER_RATIO)
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" lim
+
+definition
+  tends_real_real :: "(real => real) => real => real => bool"  where
+  "tends_real_real == %f l x0. tends f l (mtop mr1, nets.tendsto (mr1, x0))"
+
+lemma tends_real_real: "tends_real_real f l x0 = tends f l (mtop mr1, nets.tendsto (mr1, x0))"
+  by (import lim tends_real_real)
+
+lemma LIM: "tends_real_real f y0 x0 =
+(ALL e>0.
+    EX d>0.
+       ALL x. 0 < abs (x - x0) & abs (x - x0) < d --> abs (f x - y0) < e)"
+  by (import lim LIM)
+
+lemma LIM_CONST: "tends_real_real (%x. k) k x"
+  by (import lim LIM_CONST)
+
+lemma LIM_ADD: "tends_real_real f l x & tends_real_real g m x
+==> tends_real_real (%x. f x + g x) (l + m) x"
+  by (import lim LIM_ADD)
+
+lemma LIM_MUL: "tends_real_real f l x & tends_real_real g m x
+==> tends_real_real (%x. f x * g x) (l * m) x"
+  by (import lim LIM_MUL)
+
+lemma LIM_NEG: "tends_real_real f l x = tends_real_real (%x. - f x) (- l) x"
+  by (import lim LIM_NEG)
+
+lemma LIM_INV: "tends_real_real f l x & l ~= 0
+==> tends_real_real (%x. inverse (f x)) (inverse l) x"
+  by (import lim LIM_INV)
+
+lemma LIM_SUB: "tends_real_real f l x & tends_real_real g m x
+==> tends_real_real (%x. f x - g x) (l - m) x"
+  by (import lim LIM_SUB)
+
+lemma LIM_DIV: "tends_real_real f l x & tends_real_real g m x & m ~= 0
+==> tends_real_real (%x. f x / g x) (l / m) x"
+  by (import lim LIM_DIV)
+
+lemma LIM_NULL: "tends_real_real f l x = tends_real_real (%x. f x - l) 0 x"
+  by (import lim LIM_NULL)
+
+lemma LIM_X: "tends_real_real (%x. x) x0 x0"
+  by (import lim LIM_X)
+
+lemma LIM_UNIQ: "tends_real_real f l x & tends_real_real f m x ==> l = m"
+  by (import lim LIM_UNIQ)
+
+lemma LIM_EQUAL: "(!!x. x ~= x0 ==> f x = g x)
+==> tends_real_real f l x0 = tends_real_real g l x0"
+  by (import lim LIM_EQUAL)
+
+lemma LIM_TRANSFORM: "tends_real_real (%x. f x - g x) 0 x0 & tends_real_real g l x0
+==> tends_real_real f l x0"
+  by (import lim LIM_TRANSFORM)
+
+definition
+  diffl :: "(real => real) => real => real => bool"  where
+  "diffl == %f l x. tends_real_real (%h. (f (x + h) - f x) / h) l 0"
+
+lemma diffl: "diffl f l x = tends_real_real (%h. (f (x + h) - f x) / h) l 0"
+  by (import lim diffl)
+
+definition
+  contl :: "(real => real) => real => bool"  where
+  "contl == %f x. tends_real_real (%h. f (x + h)) (f x) 0"
+
+lemma contl: "contl f x = tends_real_real (%h. f (x + h)) (f x) 0"
+  by (import lim contl)
+
+consts
+  differentiable :: "(real => real) => real => bool" 
+
+defs
+  differentiable_def: "lim.differentiable == %f x. EX l. diffl f l x"
+
+lemma differentiable: "lim.differentiable f x = (EX l. diffl f l x)"
+  by (import lim differentiable)
+
+lemma DIFF_UNIQ: "diffl f l x & diffl f m x ==> l = m"
+  by (import lim DIFF_UNIQ)
+
+lemma DIFF_CONT: "diffl f l x ==> contl f x"
+  by (import lim DIFF_CONT)
+
+lemma CONTL_LIM: "contl f x = tends_real_real f (f x) x"
+  by (import lim CONTL_LIM)
+
+lemma DIFF_CARAT: "diffl f l x =
+(EX g. (ALL z. f z - f x = g z * (z - x)) & contl g x & g x = l)"
+  by (import lim DIFF_CARAT)
+
+lemma CONT_CONST: "contl (%x. k) x"
+  by (import lim CONT_CONST)
+
+lemma CONT_ADD: "contl f x & contl g x ==> contl (%x. f x + g x) x"
+  by (import lim CONT_ADD)
+
+lemma CONT_MUL: "contl f x & contl g x ==> contl (%x. f x * g x) x"
+  by (import lim CONT_MUL)
+
+lemma CONT_NEG: "contl f x ==> contl (%x. - f x) x"
+  by (import lim CONT_NEG)
+
+lemma CONT_INV: "contl f x & f x ~= 0 ==> contl (%x. inverse (f x)) x"
+  by (import lim CONT_INV)
+
+lemma CONT_SUB: "contl f x & contl g x ==> contl (%x. f x - g x) x"
+  by (import lim CONT_SUB)
+
+lemma CONT_DIV: "contl f x & contl g x & g x ~= 0 ==> contl (%x. f x / g x) x"
+  by (import lim CONT_DIV)
+
+lemma CONT_COMPOSE: "contl f x & contl g (f x) ==> contl (%x. g (f x)) x"
+  by (import lim CONT_COMPOSE)
+
+lemma IVT: "a <= b & (f a <= y & y <= f b) & (ALL x. a <= x & x <= b --> contl f x)
+==> EX x>=a. x <= b & f x = y"
+  by (import lim IVT)
+
+lemma IVT2: "a <= b & (f b <= y & y <= f a) & (ALL x. a <= x & x <= b --> contl f x)
+==> EX x>=a. x <= b & f x = y"
+  by (import lim IVT2)
+
+lemma DIFF_CONST: "diffl (%x. k) 0 x"
+  by (import lim DIFF_CONST)
+
+lemma DIFF_ADD: "diffl f l x & diffl g m x ==> diffl (%x. f x + g x) (l + m) x"
+  by (import lim DIFF_ADD)
+
+lemma DIFF_MUL: "diffl f l x & diffl g m x ==> diffl (%x. f x * g x) (l * g x + m * f x) x"
+  by (import lim DIFF_MUL)
+
+lemma DIFF_CMUL: "diffl f l x ==> diffl (%x. c * f x) (c * l) x"
+  by (import lim DIFF_CMUL)
+
+lemma DIFF_NEG: "diffl f l x ==> diffl (%x. - f x) (- l) x"
+  by (import lim DIFF_NEG)
+
+lemma DIFF_SUB: "diffl f l x & diffl g m x ==> diffl (%x. f x - g x) (l - m) x"
+  by (import lim DIFF_SUB)
+
+lemma DIFF_CHAIN: "diffl f l (g x) & diffl g m x ==> diffl (%x. f (g x)) (l * m) x"
+  by (import lim DIFF_CHAIN)
+
+lemma DIFF_X: "diffl (%x. x) 1 x"
+  by (import lim DIFF_X)
+
+lemma DIFF_POW: "diffl (%x. x ^ n) (real n * x ^ (n - 1)) x"
+  by (import lim DIFF_POW)
+
+lemma DIFF_XM1: "x ~= 0 ==> diffl inverse (- (inverse x ^ 2)) x"
+  by (import lim DIFF_XM1)
+
+lemma DIFF_INV: "diffl f l x & f x ~= 0 ==> diffl (%x. inverse (f x)) (- (l / f x ^ 2)) x"
+  by (import lim DIFF_INV)
+
+lemma DIFF_DIV: "diffl f l x & diffl g m x & g x ~= 0
+==> diffl (%x. f x / g x) ((l * g x - m * f x) / g x ^ 2) x"
+  by (import lim DIFF_DIV)
+
+lemma DIFF_SUM: "(!!r. m <= r & r < m + n ==> diffl (f r) (f' r x) x)
+==> diffl (%x. real.sum (m, n) (%n. f n x)) (real.sum (m, n) (%r. f' r x)) x"
+  by (import lim DIFF_SUM)
+
+lemma CONT_BOUNDED: "a <= b & (ALL x. a <= x & x <= b --> contl f x)
+==> EX M. ALL x. a <= x & x <= b --> f x <= M"
+  by (import lim CONT_BOUNDED)
+
+lemma CONT_HASSUP: "a <= b & (ALL x. a <= x & x <= b --> contl f x)
+==> EX M. (ALL x. a <= x & x <= b --> f x <= M) &
+          (ALL N<M. EX x>=a. x <= b & N < f x)"
+  by (import lim CONT_HASSUP)
+
+lemma CONT_ATTAINS: "a <= b & (ALL x. a <= x & x <= b --> contl f x)
+==> EX x. (ALL xa. a <= xa & xa <= b --> f xa <= x) &
+          (EX xa>=a. xa <= b & f xa = x)"
+  by (import lim CONT_ATTAINS)
+
+lemma CONT_ATTAINS2: "a <= b & (ALL x. a <= x & x <= b --> contl f x)
+==> EX x. (ALL xa. a <= xa & xa <= b --> x <= f xa) &
+          (EX xa>=a. xa <= b & f xa = x)"
+  by (import lim CONT_ATTAINS2)
+
+lemma CONT_ATTAINS_ALL: "a <= b & (ALL x. a <= x & x <= b --> contl f x)
+==> EX x M.
+       x <= M &
+       (ALL y. x <= y & y <= M --> (EX x>=a. x <= b & f x = y)) &
+       (ALL xa. a <= xa & xa <= b --> x <= f xa & f xa <= M)"
+  by (import lim CONT_ATTAINS_ALL)
+
+lemma DIFF_LINC: "diffl f l x & 0 < l ==> EX d>0. ALL h. 0 < h & h < d --> f x < f (x + h)"
+  by (import lim DIFF_LINC)
+
+lemma DIFF_LDEC: "diffl f l x & l < 0 ==> EX d>0. ALL h. 0 < h & h < d --> f x < f (x - h)"
+  by (import lim DIFF_LDEC)
+
+lemma DIFF_LMAX: "diffl f l x & (EX d>0. ALL y. abs (x - y) < d --> f y <= f x) ==> l = 0"
+  by (import lim DIFF_LMAX)
+
+lemma DIFF_LMIN: "diffl f l x & (EX d>0. ALL y. abs (x - y) < d --> f x <= f y) ==> l = 0"
+  by (import lim DIFF_LMIN)
+
+lemma DIFF_LCONST: "diffl f l x & (EX d>0. ALL y. abs (x - y) < d --> f y = f x) ==> l = 0"
+  by (import lim DIFF_LCONST)
+
+lemma ROLLE: "a < b &
+f a = f b &
+(ALL x. a <= x & x <= b --> contl f x) &
+(ALL x. a < x & x < b --> lim.differentiable f x)
+==> EX z>a. z < b & diffl f 0 z"
+  by (import lim ROLLE)
+
+lemma MVT: "a < b &
+(ALL x. a <= x & x <= b --> contl f x) &
+(ALL x. a < x & x < b --> lim.differentiable f x)
+==> EX l z. a < z & z < b & diffl f l z & f b - f a = (b - a) * l"
+  by (import lim MVT)
+
+lemma DIFF_ISCONST_END: "a < b &
+(ALL x. a <= x & x <= b --> contl f x) &
+(ALL x. a < x & x < b --> diffl f 0 x)
+==> f b = f a"
+  by (import lim DIFF_ISCONST_END)
+
+lemma DIFF_ISCONST: "[| a < b &
+   (ALL x. a <= x & x <= b --> contl f x) &
+   (ALL x. a < x & x < b --> diffl f 0 x);
+   a <= x & x <= b |]
+==> f x = f a"
+  by (import lim DIFF_ISCONST)
+
+lemma DIFF_ISCONST_ALL: "(!!x. diffl f 0 x) ==> f x = f y"
+  by (import lim DIFF_ISCONST_ALL)
+
+lemma INTERVAL_ABS: "((x::real) - (d::real) <= (z::real) & z <= x + d) = (abs (z - x) <= d)"
+  by (import lim INTERVAL_ABS)
+
+lemma CONT_INJ_LEMMA: "0 < d &
+(ALL z. abs (z - x) <= d --> g (f z) = z) &
+(ALL z. abs (z - x) <= d --> contl f z)
+==> ~ (ALL z. abs (z - x) <= d --> f z <= f x)"
+  by (import lim CONT_INJ_LEMMA)
+
+lemma CONT_INJ_LEMMA2: "0 < d &
+(ALL z. abs (z - x) <= d --> g (f z) = z) &
+(ALL z. abs (z - x) <= d --> contl f z)
+==> ~ (ALL z. abs (z - x) <= d --> f x <= f z)"
+  by (import lim CONT_INJ_LEMMA2)
+
+lemma CONT_INJ_RANGE: "0 < d &
+(ALL z. abs (z - x) <= d --> g (f z) = z) &
+(ALL z. abs (z - x) <= d --> contl f z)
+==> EX e>0. ALL y. abs (y - f x) <= e --> (EX z. abs (z - x) <= d & f z = y)"
+  by (import lim CONT_INJ_RANGE)
+
+lemma CONT_INVERSE: "0 < d &
+(ALL z. abs (z - x) <= d --> g (f z) = z) &
+(ALL z. abs (z - x) <= d --> contl f z)
+==> contl g (f x)"
+  by (import lim CONT_INVERSE)
+
+lemma DIFF_INVERSE: "0 < d &
+(ALL z. abs (z - x) <= d --> g (f z) = z) &
+(ALL z. abs (z - x) <= d --> contl f z) & diffl f l x & l ~= 0
+==> diffl g (inverse l) (f x)"
+  by (import lim DIFF_INVERSE)
+
+lemma DIFF_INVERSE_LT: "0 < d &
+(ALL z. abs (z - x) < d --> g (f z) = z) &
+(ALL z. abs (z - x) < d --> contl f z) & diffl f l x & l ~= 0
+==> diffl g (inverse l) (f x)"
+  by (import lim DIFF_INVERSE_LT)
+
+lemma INTERVAL_CLEMMA: "(a::real) < (x::real) & x < (b::real)
+==> EX d>0::real. ALL y::real. abs (y - x) <= d --> a < y & y < b"
+  by (import lim INTERVAL_CLEMMA)
+
+lemma DIFF_INVERSE_OPEN: "a < x &
+x < b &
+(ALL z. a < z & z < b --> g (f z) = z & contl f z) & diffl f l x & l ~= 0
+==> diffl g (inverse l) (f x)"
+  by (import lim DIFF_INVERSE_OPEN)
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" powser
+
+lemma POWDIFF_LEMMA: "real.sum (0, Suc n) (%p. x ^ p * y ^ (Suc n - p)) =
+y * real.sum (0, Suc n) (%p. x ^ p * y ^ (n - p))"
+  by (import powser POWDIFF_LEMMA)
+
+lemma POWDIFF: "x ^ Suc n - y ^ Suc n =
+(x - y) * real.sum (0, Suc n) (%p. x ^ p * y ^ (n - p))"
+  by (import powser POWDIFF)
+
+lemma POWREV: "real.sum (0, Suc n) (%xa. x ^ xa * y ^ (n - xa)) =
+real.sum (0, Suc n) (%xa. x ^ (n - xa) * y ^ xa)"
+  by (import powser POWREV)
+
+lemma POWSER_INSIDEA: "seq.summable (%n. f n * x ^ n) & abs z < abs x
+==> seq.summable (%n. abs (f n) * z ^ n)"
+  by (import powser POWSER_INSIDEA)
+
+lemma POWSER_INSIDE: "seq.summable (%n. f n * x ^ n) & abs z < abs x
+==> seq.summable (%n. f n * z ^ n)"
+  by (import powser POWSER_INSIDE)
+
+consts
+  diffs :: "(nat => real) => nat => real" 
+
+defs
+  diffs_def: "powser.diffs == %c n. real (Suc n) * c (Suc n)"
+
+lemma diffs: "powser.diffs c = (%n. real (Suc n) * c (Suc n))"
+  by (import powser diffs)
+
+lemma DIFFS_NEG: "powser.diffs (%n. - c n) = (%x. - powser.diffs c x)"
+  by (import powser DIFFS_NEG)
+
+lemma DIFFS_LEMMA: "real.sum (0, n) (%n. powser.diffs c n * x ^ n) =
+real.sum (0, n) (%n. real n * (c n * x ^ (n - 1))) +
+real n * (c n * x ^ (n - 1))"
+  by (import powser DIFFS_LEMMA)
+
+lemma DIFFS_LEMMA2: "real.sum (0, n) (%n. real n * (c n * x ^ (n - 1))) =
+real.sum (0, n) (%n. powser.diffs c n * x ^ n) -
+real n * (c n * x ^ (n - 1))"
+  by (import powser DIFFS_LEMMA2)
+
+lemma DIFFS_EQUIV: "seq.summable (%n. powser.diffs c n * x ^ n)
+==> seq.sums (%n. real n * (c n * x ^ (n - 1)))
+     (seq.suminf (%n. powser.diffs c n * x ^ n))"
+  by (import powser DIFFS_EQUIV)
+
+lemma TERMDIFF_LEMMA1: "real.sum (0, m) (%p. (z + h) ^ (m - p) * z ^ p - z ^ m) =
+real.sum (0, m) (%p. z ^ p * ((z + h) ^ (m - p) - z ^ (m - p)))"
+  by (import powser TERMDIFF_LEMMA1)
+
+lemma TERMDIFF_LEMMA2: "h ~= 0
+==> ((z + h) ^ n - z ^ n) / h - real n * z ^ (n - 1) =
+    h *
+    real.sum (0, n - 1)
+     (%p. z ^ p *
+          real.sum (0, n - 1 - p) (%q. (z + h) ^ q * z ^ (n - 2 - p - q)))"
+  by (import powser TERMDIFF_LEMMA2)
+
+lemma TERMDIFF_LEMMA3: "h ~= 0 & abs z <= k' & abs (z + h) <= k'
+==> abs (((z + h) ^ n - z ^ n) / h - real n * z ^ (n - 1))
+    <= real n * (real (n - 1) * (k' ^ (n - 2) * abs h))"
+  by (import powser TERMDIFF_LEMMA3)
+
+lemma TERMDIFF_LEMMA4: "0 < k & (ALL h. 0 < abs h & abs h < k --> abs (f h) <= k' * abs h)
+==> tends_real_real f 0 0"
+  by (import powser TERMDIFF_LEMMA4)
+
+lemma TERMDIFF_LEMMA5: "0 < k &
+seq.summable f &
+(ALL h. 0 < abs h & abs h < k --> (ALL n. abs (g h n) <= f n * abs h))
+==> tends_real_real (%h. seq.suminf (g h)) 0 0"
+  by (import powser TERMDIFF_LEMMA5)
+
+lemma TERMDIFF: "seq.summable (%n. c n * k' ^ n) &
+seq.summable (%n. powser.diffs c n * k' ^ n) &
+seq.summable (%n. powser.diffs (powser.diffs c) n * k' ^ n) & abs x < abs k'
+==> diffl (%x. seq.suminf (%n. c n * x ^ n))
+     (seq.suminf (%n. powser.diffs c n * x ^ n)) x"
+  by (import powser TERMDIFF)
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" transc
+
+consts
+  exp :: "real => real" 
+
+defs
+  exp_def: "transc.exp == %x. seq.suminf (%n. inverse (real (FACT n)) * x ^ n)"
+
+lemma exp: "transc.exp x = seq.suminf (%n. inverse (real (FACT n)) * x ^ n)"
+  by (import transc exp)
+
+consts
+  cos :: "real => real" 
+
+defs
+  cos_def: "transc.cos ==
+%x. seq.suminf
+     (%n. (if EVEN n then (- 1) ^ (n div 2) / real (FACT n) else 0) * x ^ n)"
+
+lemma cos: "transc.cos x =
+seq.suminf
+ (%n. (if EVEN n then (- 1) ^ (n div 2) / real (FACT n) else 0) * x ^ n)"
+  by (import transc cos)
+
+consts
+  sin :: "real => real" 
+
+defs
+  sin_def: "transc.sin ==
+%x. seq.suminf
+     (%n. (if EVEN n then 0 else (- 1) ^ ((n - 1) div 2) / real (FACT n)) *
+          x ^ n)"
+
+lemma sin: "transc.sin x =
+seq.suminf
+ (%n. (if EVEN n then 0 else (- 1) ^ ((n - 1) div 2) / real (FACT n)) *
+      x ^ n)"
+  by (import transc sin)
+
+lemma EXP_CONVERGES: "seq.sums (%n. inverse (real (FACT n)) * x ^ n) (transc.exp x)"
+  by (import transc EXP_CONVERGES)
+
+lemma SIN_CONVERGES: "seq.sums
+ (%n. (if EVEN n then 0 else (- 1) ^ ((n - 1) div 2) / real (FACT n)) *
+      x ^ n)
+ (transc.sin x)"
+  by (import transc SIN_CONVERGES)
+
+lemma COS_CONVERGES: "seq.sums
+ (%n. (if EVEN n then (- 1) ^ (n div 2) / real (FACT n) else 0) * x ^ n)
+ (transc.cos x)"
+  by (import transc COS_CONVERGES)
+
+lemma EXP_FDIFF: "powser.diffs (%n. inverse (real (FACT n))) = (%n. inverse (real (FACT n)))"
+  by (import transc EXP_FDIFF)
+
+lemma SIN_FDIFF: "powser.diffs
+ (%n. if EVEN n then 0 else (- 1) ^ ((n - 1) div 2) / real (FACT n)) =
+(%n. if EVEN n then (- 1) ^ (n div 2) / real (FACT n) else 0)"
+  by (import transc SIN_FDIFF)
+
+lemma COS_FDIFF: "powser.diffs (%n. if EVEN n then (- 1) ^ (n div 2) / real (FACT n) else 0) =
+(%n. - (if EVEN n then 0 else (- 1) ^ ((n - 1) div 2) / real (FACT n)))"
+  by (import transc COS_FDIFF)
+
+lemma SIN_NEGLEMMA: "- transc.sin x =
+seq.suminf
+ (%n. - ((if EVEN n then 0 else (- 1) ^ ((n - 1) div 2) / real (FACT n)) *
+         x ^ n))"
+  by (import transc SIN_NEGLEMMA)
+
+lemma DIFF_EXP: "diffl transc.exp (transc.exp x) x"
+  by (import transc DIFF_EXP)
+
+lemma DIFF_SIN: "diffl transc.sin (transc.cos x) x"
+  by (import transc DIFF_SIN)
+
+lemma DIFF_COS: "diffl transc.cos (- transc.sin x) x"
+  by (import transc DIFF_COS)
+
+lemma DIFF_COMPOSITE: "(diffl f l x & f x ~= 0 --> diffl (%x. inverse (f x)) (- (l / f x ^ 2)) x) &
+(diffl f l x & diffl g m x & g x ~= 0 -->
+ diffl (%x. f x / g x) ((l * g x - m * f x) / g x ^ 2) x) &
+(diffl f l x & diffl g m x --> diffl (%x. f x + g x) (l + m) x) &
+(diffl f l x & diffl g m x -->
+ diffl (%x. f x * g x) (l * g x + m * f x) x) &
+(diffl f l x & diffl g m x --> diffl (%x. f x - g x) (l - m) x) &
+(diffl f l x --> diffl (%x. - f x) (- l) x) &
+(diffl g m x --> diffl (%x. g x ^ n) (real n * g x ^ (n - 1) * m) x) &
+(diffl g m x --> diffl (%x. transc.exp (g x)) (transc.exp (g x) * m) x) &
+(diffl g m x --> diffl (%x. transc.sin (g x)) (transc.cos (g x) * m) x) &
+(diffl g m x --> diffl (%x. transc.cos (g x)) (- transc.sin (g x) * m) x)"
+  by (import transc DIFF_COMPOSITE)
+
+lemma EXP_0: "transc.exp 0 = 1"
+  by (import transc EXP_0)
+
+lemma EXP_LE_X: "0 <= x ==> 1 + x <= transc.exp x"
+  by (import transc EXP_LE_X)
+
+lemma EXP_LT_1: "0 < x ==> 1 < transc.exp x"
+  by (import transc EXP_LT_1)
+
+lemma EXP_ADD_MUL: "transc.exp (x + y) * transc.exp (- x) = transc.exp y"
+  by (import transc EXP_ADD_MUL)
+
+lemma EXP_NEG_MUL: "transc.exp x * transc.exp (- x) = 1"
+  by (import transc EXP_NEG_MUL)
+
+lemma EXP_NEG_MUL2: "transc.exp (- x) * transc.exp x = 1"
+  by (import transc EXP_NEG_MUL2)
+
+lemma EXP_NEG: "transc.exp (- x) = inverse (transc.exp x)"
+  by (import transc EXP_NEG)
+
+lemma EXP_ADD: "transc.exp (x + y) = transc.exp x * transc.exp y"
+  by (import transc EXP_ADD)
+
+lemma EXP_POS_LE: "0 <= transc.exp x"
+  by (import transc EXP_POS_LE)
+
+lemma EXP_NZ: "transc.exp x ~= 0"
+  by (import transc EXP_NZ)
+
+lemma EXP_POS_LT: "0 < transc.exp x"
+  by (import transc EXP_POS_LT)
+
+lemma EXP_N: "transc.exp (real n * x) = transc.exp x ^ n"
+  by (import transc EXP_N)
+
+lemma EXP_SUB: "transc.exp (x - y) = transc.exp x / transc.exp y"
+  by (import transc EXP_SUB)
+
+lemma EXP_MONO_IMP: "x < y ==> transc.exp x < transc.exp y"
+  by (import transc EXP_MONO_IMP)
+
+lemma EXP_MONO_LT: "(transc.exp x < transc.exp y) = (x < y)"
+  by (import transc EXP_MONO_LT)
+
+lemma EXP_MONO_LE: "(transc.exp x <= transc.exp y) = (x <= y)"
+  by (import transc EXP_MONO_LE)
+
+lemma EXP_INJ: "(transc.exp x = transc.exp y) = (x = y)"
+  by (import transc EXP_INJ)
+
+lemma EXP_TOTAL_LEMMA: "1 <= y ==> EX x>=0. x <= y - 1 & transc.exp x = y"
+  by (import transc EXP_TOTAL_LEMMA)
+
+lemma EXP_TOTAL: "0 < y ==> EX x. transc.exp x = y"
+  by (import transc EXP_TOTAL)
+
+consts
+  ln :: "real => real" 
+
+defs
+  ln_def: "transc.ln == %x. SOME u. transc.exp u = x"
+
+lemma ln: "transc.ln x = (SOME u. transc.exp u = x)"
+  by (import transc ln)
+
+lemma LN_EXP: "transc.ln (transc.exp x) = x"
+  by (import transc LN_EXP)
+
+lemma EXP_LN: "(transc.exp (transc.ln x) = x) = (0 < x)"
+  by (import transc EXP_LN)
+
+lemma LN_MUL: "0 < x & 0 < y ==> transc.ln (x * y) = transc.ln x + transc.ln y"
+  by (import transc LN_MUL)
+
+lemma LN_INJ: "0 < x & 0 < y ==> (transc.ln x = transc.ln y) = (x = y)"
+  by (import transc LN_INJ)
+
+lemma LN_1: "transc.ln 1 = 0"
+  by (import transc LN_1)
+
+lemma LN_INV: "0 < x ==> transc.ln (inverse x) = - transc.ln x"
+  by (import transc LN_INV)
+
+lemma LN_DIV: "0 < x & 0 < y ==> transc.ln (x / y) = transc.ln x - transc.ln y"
+  by (import transc LN_DIV)
+
+lemma LN_MONO_LT: "0 < x & 0 < y ==> (transc.ln x < transc.ln y) = (x < y)"
+  by (import transc LN_MONO_LT)
+
+lemma LN_MONO_LE: "0 < x & 0 < y ==> (transc.ln x <= transc.ln y) = (x <= y)"
+  by (import transc LN_MONO_LE)
+
+lemma LN_POW: "0 < x ==> transc.ln (x ^ n) = real n * transc.ln x"
+  by (import transc LN_POW)
+
+lemma LN_LE: "0 <= x ==> transc.ln (1 + x) <= x"
+  by (import transc LN_LE)
+
+lemma LN_LT_X: "0 < x ==> transc.ln x < x"
+  by (import transc LN_LT_X)
+
+lemma LN_POS: "1 <= x ==> 0 <= transc.ln x"
+  by (import transc LN_POS)
+
+consts
+  root :: "nat => real => real" 
+
+defs
+  root_def: "transc.root == %n x. SOME u. (0 < x --> 0 < u) & u ^ n = x"
+
+lemma root: "transc.root n x = (SOME u. (0 < x --> 0 < u) & u ^ n = x)"
+  by (import transc root)
+
+consts
+  sqrt :: "real => real" 
+
+defs
+  sqrt_def: "transc.sqrt == transc.root 2"
+
+lemma sqrt: "transc.sqrt x = transc.root 2 x"
+  by (import transc sqrt)
+
+lemma ROOT_LT_LEMMA: "0 < x ==> transc.exp (transc.ln x / real (Suc n)) ^ Suc n = x"
+  by (import transc ROOT_LT_LEMMA)
+
+lemma ROOT_LN: "0 < x ==> transc.root (Suc n) x = transc.exp (transc.ln x / real (Suc n))"
+  by (import transc ROOT_LN)
+
+lemma ROOT_0: "transc.root (Suc n) 0 = 0"
+  by (import transc ROOT_0)
+
+lemma ROOT_1: "transc.root (Suc n) 1 = 1"
+  by (import transc ROOT_1)
+
+lemma ROOT_POS_LT: "0 < x ==> 0 < transc.root (Suc n) x"
+  by (import transc ROOT_POS_LT)
+
+lemma ROOT_POW_POS: "0 <= x ==> transc.root (Suc n) x ^ Suc n = x"
+  by (import transc ROOT_POW_POS)
+
+lemma POW_ROOT_POS: "0 <= x ==> transc.root (Suc n) (x ^ Suc n) = x"
+  by (import transc POW_ROOT_POS)
+
+lemma ROOT_POS: "0 <= x ==> 0 <= transc.root (Suc n) x"
+  by (import transc ROOT_POS)
+
+lemma ROOT_POS_UNIQ: "0 <= x & 0 <= y & y ^ Suc n = x ==> transc.root (Suc n) x = y"
+  by (import transc ROOT_POS_UNIQ)
+
+lemma ROOT_MUL: "0 <= x & 0 <= y
+==> transc.root (Suc n) (x * y) =
+    transc.root (Suc n) x * transc.root (Suc n) y"
+  by (import transc ROOT_MUL)
+
+lemma ROOT_INV: "0 <= x ==> transc.root (Suc n) (inverse x) = inverse (transc.root (Suc n) x)"
+  by (import transc ROOT_INV)
+
+lemma ROOT_DIV: "0 <= xa & 0 <= xb
+==> transc.root (Suc x) (xa / xb) =
+    transc.root (Suc x) xa / transc.root (Suc x) xb"
+  by (import transc ROOT_DIV)
+
+lemma ROOT_MONO_LE: "0 <= x & x <= y ==> transc.root (Suc n) x <= transc.root (Suc n) y"
+  by (import transc ROOT_MONO_LE)
+
+lemma SQRT_0: "transc.sqrt 0 = 0"
+  by (import transc SQRT_0)
+
+lemma SQRT_1: "transc.sqrt 1 = 1"
+  by (import transc SQRT_1)
+
+lemma SQRT_POS_LT: "0 < x ==> 0 < transc.sqrt x"
+  by (import transc SQRT_POS_LT)
+
+lemma SQRT_POS_LE: "0 <= x ==> 0 <= transc.sqrt x"
+  by (import transc SQRT_POS_LE)
+
+lemma SQRT_POW2: "(transc.sqrt x ^ 2 = x) = (0 <= x)"
+  by (import transc SQRT_POW2)
+
+lemma SQRT_POW_2: "0 <= x ==> transc.sqrt x ^ 2 = x"
+  by (import transc SQRT_POW_2)
+
+lemma POW_2_SQRT: "0 <= x ==> transc.sqrt (x ^ 2) = x"
+  by (import transc POW_2_SQRT)
+
+lemma SQRT_POS_UNIQ: "0 <= x & 0 <= xa & xa ^ 2 = x ==> transc.sqrt x = xa"
+  by (import transc SQRT_POS_UNIQ)
+
+lemma SQRT_MUL: "0 <= x & 0 <= xa ==> transc.sqrt (x * xa) = transc.sqrt x * transc.sqrt xa"
+  by (import transc SQRT_MUL)
+
+lemma SQRT_INV: "0 <= x ==> transc.sqrt (inverse x) = inverse (transc.sqrt x)"
+  by (import transc SQRT_INV)
+
+lemma SQRT_DIV: "0 <= x & 0 <= xa ==> transc.sqrt (x / xa) = transc.sqrt x / transc.sqrt xa"
+  by (import transc SQRT_DIV)
+
+lemma SQRT_MONO_LE: "0 <= x & x <= xa ==> transc.sqrt x <= transc.sqrt xa"
+  by (import transc SQRT_MONO_LE)
+
+lemma SQRT_EVEN_POW2: "EVEN n ==> transc.sqrt (2 ^ n) = 2 ^ (n div 2)"
+  by (import transc SQRT_EVEN_POW2)
+
+lemma REAL_DIV_SQRT: "0 <= x ==> x / transc.sqrt x = transc.sqrt x"
+  by (import transc REAL_DIV_SQRT)
+
+lemma SQRT_EQ: "x ^ 2 = y & 0 <= x ==> x = transc.sqrt y"
+  by (import transc SQRT_EQ)
+
+lemma SIN_0: "transc.sin 0 = 0"
+  by (import transc SIN_0)
+
+lemma COS_0: "transc.cos 0 = 1"
+  by (import transc COS_0)
+
+lemma SIN_CIRCLE: "transc.sin x ^ 2 + transc.cos x ^ 2 = 1"
+  by (import transc SIN_CIRCLE)
+
+lemma SIN_BOUND: "abs (transc.sin x) <= 1"
+  by (import transc SIN_BOUND)
+
+lemma SIN_BOUNDS: "- 1 <= transc.sin x & transc.sin x <= 1"
+  by (import transc SIN_BOUNDS)
+
+lemma COS_BOUND: "abs (transc.cos x) <= 1"
+  by (import transc COS_BOUND)
+
+lemma COS_BOUNDS: "- 1 <= transc.cos x & transc.cos x <= 1"
+  by (import transc COS_BOUNDS)
+
+lemma SIN_COS_ADD: "(transc.sin (x + y) -
+ (transc.sin x * transc.cos y + transc.cos x * transc.sin y)) ^
+2 +
+(transc.cos (x + y) -
+ (transc.cos x * transc.cos y - transc.sin x * transc.sin y)) ^
+2 =
+0"
+  by (import transc SIN_COS_ADD)
+
+lemma SIN_COS_NEG: "(transc.sin (- x) + transc.sin x) ^ 2 +
+(transc.cos (- x) - transc.cos x) ^ 2 =
+0"
+  by (import transc SIN_COS_NEG)
+
+lemma SIN_ADD: "transc.sin (x + y) =
+transc.sin x * transc.cos y + transc.cos x * transc.sin y"
+  by (import transc SIN_ADD)
+
+lemma COS_ADD: "transc.cos (x + y) =
+transc.cos x * transc.cos y - transc.sin x * transc.sin y"
+  by (import transc COS_ADD)
+
+lemma SIN_NEG: "transc.sin (- x) = - transc.sin x"
+  by (import transc SIN_NEG)
+
+lemma COS_NEG: "transc.cos (- x) = transc.cos x"
+  by (import transc COS_NEG)
+
+lemma SIN_DOUBLE: "transc.sin (2 * x) = 2 * (transc.sin x * transc.cos x)"
+  by (import transc SIN_DOUBLE)
+
+lemma COS_DOUBLE: "transc.cos (2 * x) = transc.cos x ^ 2 - transc.sin x ^ 2"
+  by (import transc COS_DOUBLE)
+
+lemma SIN_PAIRED: "seq.sums (%n. (- 1) ^ n / real (FACT (2 * n + 1)) * x ^ (2 * n + 1))
+ (transc.sin x)"
+  by (import transc SIN_PAIRED)
+
+lemma SIN_POS: "0 < x & x < 2 ==> 0 < transc.sin x"
+  by (import transc SIN_POS)
+
+lemma COS_PAIRED: "seq.sums (%n. (- 1) ^ n / real (FACT (2 * n)) * x ^ (2 * n)) (transc.cos x)"
+  by (import transc COS_PAIRED)
+
+lemma COS_2: "transc.cos 2 < 0"
+  by (import transc COS_2)
+
+lemma COS_ISZERO: "EX! x. 0 <= x & x <= 2 & transc.cos x = 0"
+  by (import transc COS_ISZERO)
+
+consts
+  pi :: "real" 
+
+defs
+  pi_def: "transc.pi == 2 * (SOME x. 0 <= x & x <= 2 & transc.cos x = 0)"
+
+lemma pi: "transc.pi = 2 * (SOME x. 0 <= x & x <= 2 & transc.cos x = 0)"
+  by (import transc pi)
+
+lemma PI2: "transc.pi / 2 = (SOME x. 0 <= x & x <= 2 & transc.cos x = 0)"
+  by (import transc PI2)
+
+lemma COS_PI2: "transc.cos (transc.pi / 2) = 0"
+  by (import transc COS_PI2)
+
+lemma PI2_BOUNDS: "0 < transc.pi / 2 & transc.pi / 2 < 2"
+  by (import transc PI2_BOUNDS)
+
+lemma PI_POS: "0 < transc.pi"
+  by (import transc PI_POS)
+
+lemma SIN_PI2: "transc.sin (transc.pi / 2) = 1"
+  by (import transc SIN_PI2)
+
+lemma COS_PI: "transc.cos transc.pi = - 1"
+  by (import transc COS_PI)
+
+lemma SIN_PI: "transc.sin transc.pi = 0"
+  by (import transc SIN_PI)
+
+lemma SIN_COS: "transc.sin x = transc.cos (transc.pi / 2 - x)"
+  by (import transc SIN_COS)
+
+lemma COS_SIN: "transc.cos x = transc.sin (transc.pi / 2 - x)"
+  by (import transc COS_SIN)
+
+lemma SIN_PERIODIC_PI: "transc.sin (x + transc.pi) = - transc.sin x"
+  by (import transc SIN_PERIODIC_PI)
+
+lemma COS_PERIODIC_PI: "transc.cos (x + transc.pi) = - transc.cos x"
+  by (import transc COS_PERIODIC_PI)
+
+lemma SIN_PERIODIC: "transc.sin (x + 2 * transc.pi) = transc.sin x"
+  by (import transc SIN_PERIODIC)
+
+lemma COS_PERIODIC: "transc.cos (x + 2 * transc.pi) = transc.cos x"
+  by (import transc COS_PERIODIC)
+
+lemma COS_NPI: "transc.cos (real n * transc.pi) = (- 1) ^ n"
+  by (import transc COS_NPI)
+
+lemma SIN_NPI: "transc.sin (real (n::nat) * transc.pi) = (0::real)"
+  by (import transc SIN_NPI)
+
+lemma SIN_POS_PI2: "0 < x & x < transc.pi / 2 ==> 0 < transc.sin x"
+  by (import transc SIN_POS_PI2)
+
+lemma COS_POS_PI2: "0 < x & x < transc.pi / 2 ==> 0 < transc.cos x"
+  by (import transc COS_POS_PI2)
+
+lemma COS_POS_PI: "- (transc.pi / 2) < x & x < transc.pi / 2 ==> 0 < transc.cos x"
+  by (import transc COS_POS_PI)
+
+lemma SIN_POS_PI: "0 < x & x < transc.pi ==> 0 < transc.sin x"
+  by (import transc SIN_POS_PI)
+
+lemma COS_POS_PI2_LE: "0 <= x & x <= transc.pi / 2 ==> 0 <= transc.cos x"
+  by (import transc COS_POS_PI2_LE)
+
+lemma COS_POS_PI_LE: "- (transc.pi / 2) <= x & x <= transc.pi / 2 ==> 0 <= transc.cos x"
+  by (import transc COS_POS_PI_LE)
+
+lemma SIN_POS_PI2_LE: "0 <= x & x <= transc.pi / 2 ==> 0 <= transc.sin x"
+  by (import transc SIN_POS_PI2_LE)
+
+lemma SIN_POS_PI_LE: "0 <= x & x <= transc.pi ==> 0 <= transc.sin x"
+  by (import transc SIN_POS_PI_LE)
+
+lemma COS_TOTAL: "- 1 <= y & y <= 1 ==> EX! x. 0 <= x & x <= transc.pi & transc.cos x = y"
+  by (import transc COS_TOTAL)
+
+lemma SIN_TOTAL: "- 1 <= y & y <= 1
+==> EX! x. - (transc.pi / 2) <= x & x <= transc.pi / 2 & transc.sin x = y"
+  by (import transc SIN_TOTAL)
+
+lemma COS_ZERO_LEMMA: "0 <= x & transc.cos x = 0 ==> EX n. ~ EVEN n & x = real n * (transc.pi / 2)"
+  by (import transc COS_ZERO_LEMMA)
+
+lemma SIN_ZERO_LEMMA: "0 <= x & transc.sin x = 0 ==> EX n. EVEN n & x = real n * (transc.pi / 2)"
+  by (import transc SIN_ZERO_LEMMA)
+
+lemma COS_ZERO: "(transc.cos x = 0) =
+((EX n. ~ EVEN n & x = real n * (transc.pi / 2)) |
+ (EX n. ~ EVEN n & x = - (real n * (transc.pi / 2))))"
+  by (import transc COS_ZERO)
+
+lemma SIN_ZERO: "(transc.sin x = 0) =
+((EX n. EVEN n & x = real n * (transc.pi / 2)) |
+ (EX n. EVEN n & x = - (real n * (transc.pi / 2))))"
+  by (import transc SIN_ZERO)
+
+consts
+  tan :: "real => real" 
+
+defs
+  tan_def: "transc.tan == %x. transc.sin x / transc.cos x"
+
+lemma tan: "transc.tan x = transc.sin x / transc.cos x"
+  by (import transc tan)
+
+lemma TAN_0: "transc.tan 0 = 0"
+  by (import transc TAN_0)
+
+lemma TAN_PI: "transc.tan transc.pi = 0"
+  by (import transc TAN_PI)
+
+lemma TAN_NPI: "transc.tan (real (n::nat) * transc.pi) = (0::real)"
+  by (import transc TAN_NPI)
+
+lemma TAN_NEG: "transc.tan (- x) = - transc.tan x"
+  by (import transc TAN_NEG)
+
+lemma TAN_PERIODIC: "transc.tan (x + 2 * transc.pi) = transc.tan x"
+  by (import transc TAN_PERIODIC)
+
+lemma TAN_ADD: "transc.cos x ~= 0 & transc.cos y ~= 0 & transc.cos (x + y) ~= 0
+==> transc.tan (x + y) =
+    (transc.tan x + transc.tan y) / (1 - transc.tan x * transc.tan y)"
+  by (import transc TAN_ADD)
+
+lemma TAN_DOUBLE: "transc.cos x ~= 0 & transc.cos (2 * x) ~= 0
+==> transc.tan (2 * x) = 2 * transc.tan x / (1 - transc.tan x ^ 2)"
+  by (import transc TAN_DOUBLE)
+
+lemma TAN_POS_PI2: "0 < x & x < transc.pi / 2 ==> 0 < transc.tan x"
+  by (import transc TAN_POS_PI2)
+
+lemma DIFF_TAN: "transc.cos x ~= 0 ==> diffl transc.tan (inverse (transc.cos x ^ 2)) x"
+  by (import transc DIFF_TAN)
+
+lemma TAN_TOTAL_LEMMA: "0 < y ==> EX x>0. x < transc.pi / 2 & y < transc.tan x"
+  by (import transc TAN_TOTAL_LEMMA)
+
+lemma TAN_TOTAL_POS: "0 <= y ==> EX x>=0. x < transc.pi / 2 & transc.tan x = y"
+  by (import transc TAN_TOTAL_POS)
+
+lemma TAN_TOTAL: "EX! x. - (transc.pi / 2) < x & x < transc.pi / 2 & transc.tan x = y"
+  by (import transc TAN_TOTAL)
+
+definition
+  asn :: "real => real"  where
+  "asn ==
+%y. SOME x. - (transc.pi / 2) <= x & x <= transc.pi / 2 & transc.sin x = y"
+
+lemma asn: "asn y =
+(SOME x. - (transc.pi / 2) <= x & x <= transc.pi / 2 & transc.sin x = y)"
+  by (import transc asn)
+
+definition
+  acs :: "real => real"  where
+  "acs == %y. SOME x. 0 <= x & x <= transc.pi & transc.cos x = y"
+
+lemma acs: "acs y = (SOME x. 0 <= x & x <= transc.pi & transc.cos x = y)"
+  by (import transc acs)
+
+definition
+  atn :: "real => real"  where
+  "atn ==
+%y. SOME x. - (transc.pi / 2) < x & x < transc.pi / 2 & transc.tan x = y"
+
+lemma atn: "atn y =
+(SOME x. - (transc.pi / 2) < x & x < transc.pi / 2 & transc.tan x = y)"
+  by (import transc atn)
+
+lemma ASN: "- 1 <= y & y <= 1
+==> - (transc.pi / 2) <= asn y &
+    asn y <= transc.pi / 2 & transc.sin (asn y) = y"
+  by (import transc ASN)
+
+lemma ASN_SIN: "- 1 <= y & y <= 1 ==> transc.sin (asn y) = y"
+  by (import transc ASN_SIN)
+
+lemma ASN_BOUNDS: "- 1 <= y & y <= 1 ==> - (transc.pi / 2) <= asn y & asn y <= transc.pi / 2"
+  by (import transc ASN_BOUNDS)
+
+lemma ASN_BOUNDS_LT: "- 1 < y & y < 1 ==> - (transc.pi / 2) < asn y & asn y < transc.pi / 2"
+  by (import transc ASN_BOUNDS_LT)
+
+lemma SIN_ASN: "- (transc.pi / 2) <= x & x <= transc.pi / 2 ==> asn (transc.sin x) = x"
+  by (import transc SIN_ASN)
+
+lemma ACS: "- 1 <= y & y <= 1
+==> 0 <= acs y & acs y <= transc.pi & transc.cos (acs y) = y"
+  by (import transc ACS)
+
+lemma ACS_COS: "- 1 <= y & y <= 1 ==> transc.cos (acs y) = y"
+  by (import transc ACS_COS)
+
+lemma ACS_BOUNDS: "- 1 <= y & y <= 1 ==> 0 <= acs y & acs y <= transc.pi"
+  by (import transc ACS_BOUNDS)
+
+lemma ACS_BOUNDS_LT: "- 1 < y & y < 1 ==> 0 < acs y & acs y < transc.pi"
+  by (import transc ACS_BOUNDS_LT)
+
+lemma COS_ACS: "0 <= x & x <= transc.pi ==> acs (transc.cos x) = x"
+  by (import transc COS_ACS)
+
+lemma ATN: "- (transc.pi / 2) < atn y & atn y < transc.pi / 2 & transc.tan (atn y) = y"
+  by (import transc ATN)
+
+lemma ATN_TAN: "transc.tan (atn x) = x"
+  by (import transc ATN_TAN)
+
+lemma ATN_BOUNDS: "- (transc.pi / 2) < atn x & atn x < transc.pi / 2"
+  by (import transc ATN_BOUNDS)
+
+lemma TAN_ATN: "- (transc.pi / 2) < x & x < transc.pi / 2 ==> atn (transc.tan x) = x"
+  by (import transc TAN_ATN)
+
+lemma TAN_SEC: "transc.cos x ~= 0 ==> 1 + transc.tan x ^ 2 = inverse (transc.cos x) ^ 2"
+  by (import transc TAN_SEC)
+
+lemma SIN_COS_SQ: "0 <= x & x <= transc.pi
+==> transc.sin x = transc.sqrt (1 - transc.cos x ^ 2)"
+  by (import transc SIN_COS_SQ)
+
+lemma COS_SIN_SQ: "- (transc.pi / 2) <= x & x <= transc.pi / 2
+==> transc.cos x = transc.sqrt (1 - transc.sin x ^ 2)"
+  by (import transc COS_SIN_SQ)
+
+lemma COS_ATN_NZ: "transc.cos (atn x) ~= 0"
+  by (import transc COS_ATN_NZ)
+
+lemma COS_ASN_NZ: "- 1 < x & x < 1 ==> transc.cos (asn x) ~= 0"
+  by (import transc COS_ASN_NZ)
+
+lemma SIN_ACS_NZ: "- 1 < x & x < 1 ==> transc.sin (acs x) ~= 0"
+  by (import transc SIN_ACS_NZ)
+
+lemma COS_SIN_SQRT: "0 <= transc.cos x ==> transc.cos x = transc.sqrt (1 - transc.sin x ^ 2)"
+  by (import transc COS_SIN_SQRT)
+
+lemma SIN_COS_SQRT: "0 <= transc.sin x ==> transc.sin x = transc.sqrt (1 - transc.cos x ^ 2)"
+  by (import transc SIN_COS_SQRT)
+
+lemma DIFF_LN: "0 < x ==> diffl transc.ln (inverse x) x"
+  by (import transc DIFF_LN)
+
+lemma DIFF_ASN_LEMMA: "- 1 < x & x < 1 ==> diffl asn (inverse (transc.cos (asn x))) x"
+  by (import transc DIFF_ASN_LEMMA)
+
+lemma DIFF_ASN: "- 1 < x & x < 1 ==> diffl asn (inverse (transc.sqrt (1 - x ^ 2))) x"
+  by (import transc DIFF_ASN)
+
+lemma DIFF_ACS_LEMMA: "- 1 < x & x < 1 ==> diffl acs (inverse (- transc.sin (acs x))) x"
+  by (import transc DIFF_ACS_LEMMA)
+
+lemma DIFF_ACS: "- 1 < x & x < 1 ==> diffl acs (- inverse (transc.sqrt (1 - x ^ 2))) x"
+  by (import transc DIFF_ACS)
+
+lemma DIFF_ATN: "diffl atn (inverse (1 + x ^ 2)) x"
+  by (import transc DIFF_ATN)
+
+definition
+  division :: "real * real => (nat => real) => bool"  where
+  "division ==
+%(a, b) D.
+   D 0 = a & (EX N. (ALL n<N. D n < D (Suc n)) & (ALL n>=N. D n = b))"
+
+lemma division: "division (a, b) D =
+(D 0 = a & (EX N. (ALL n<N. D n < D (Suc n)) & (ALL n>=N. D n = b)))"
+  by (import transc division)
+
+definition
+  dsize :: "(nat => real) => nat"  where
+  "dsize == %D. SOME N. (ALL n<N. D n < D (Suc n)) & (ALL n>=N. D n = D N)"
+
+lemma dsize: "dsize D = (SOME N. (ALL n<N. D n < D (Suc n)) & (ALL n>=N. D n = D N))"
+  by (import transc dsize)
+
+definition
+  tdiv :: "real * real => (nat => real) * (nat => real) => bool"  where
+  "tdiv ==
+%(a, b) (D, p). division (a, b) D & (ALL n. D n <= p n & p n <= D (Suc n))"
+
+lemma tdiv: "tdiv (a, b) (D, p) =
+(division (a, b) D & (ALL n. D n <= p n & p n <= D (Suc n)))"
+  by (import transc tdiv)
+
+definition
+  gauge :: "(real => bool) => (real => real) => bool"  where
+  "gauge == %E g. ALL x. E x --> 0 < g x"
+
+lemma gauge: "gauge E g = (ALL x. E x --> 0 < g x)"
+  by (import transc gauge)
+
+definition
+  fine :: "(real => real) => (nat => real) * (nat => real) => bool"  where
+  "fine == %g (D, p). ALL n<dsize D. D (Suc n) - D n < g (p n)"
+
+lemma fine: "fine g (D, p) = (ALL n<dsize D. D (Suc n) - D n < g (p n))"
+  by (import transc fine)
+
+definition
+  rsum :: "(nat => real) * (nat => real) => (real => real) => real"  where
+  "rsum == %(D, p) f. real.sum (0, dsize D) (%n. f (p n) * (D (Suc n) - D n))"
+
+lemma rsum: "rsum (D, p) f = real.sum (0, dsize D) (%n. f (p n) * (D (Suc n) - D n))"
+  by (import transc rsum)
+
+definition
+  Dint :: "real * real => (real => real) => real => bool"  where
+  "Dint ==
+%(a, b) f k.
+   ALL e>0.
+      EX g. gauge (%x. a <= x & x <= b) g &
+            (ALL D p.
+                tdiv (a, b) (D, p) & fine g (D, p) -->
+                abs (rsum (D, p) f - k) < e)"
+
+lemma Dint: "Dint (a, b) f k =
+(ALL e>0.
+    EX g. gauge (%x. a <= x & x <= b) g &
+          (ALL D p.
+              tdiv (a, b) (D, p) & fine g (D, p) -->
+              abs (rsum (D, p) f - k) < e))"
+  by (import transc Dint)
+
+lemma DIVISION_0: "a = b ==> dsize (%n. if n = 0 then a else b) = 0"
+  by (import transc DIVISION_0)
+
+lemma DIVISION_1: "a < b ==> dsize (%n. if n = 0 then a else b) = 1"
+  by (import transc DIVISION_1)
+
+lemma DIVISION_SINGLE: "a <= b ==> division (a, b) (%n. if n = 0 then a else b)"
+  by (import transc DIVISION_SINGLE)
+
+lemma DIVISION_LHS: "division (a, b) D ==> D 0 = a"
+  by (import transc DIVISION_LHS)
+
+lemma DIVISION_THM: "division (a, b) D =
+(D 0 = a & (ALL n<dsize D. D n < D (Suc n)) & (ALL n>=dsize D. D n = b))"
+  by (import transc DIVISION_THM)
+
+lemma DIVISION_RHS: "division (a, b) D ==> D (dsize D) = b"
+  by (import transc DIVISION_RHS)
+
+lemma DIVISION_LT_GEN: "division (a, b) D & m < n & n <= dsize D ==> D m < D n"
+  by (import transc DIVISION_LT_GEN)
+
+lemma DIVISION_LT: "[| division (a, b) D; n < dsize D |] ==> D 0 < D (Suc n)"
+  by (import transc DIVISION_LT)
+
+lemma DIVISION_LE: "division (a, b) D ==> a <= b"
+  by (import transc DIVISION_LE)
+
+lemma DIVISION_GT: "[| division (a, b) D; n < dsize D |] ==> D n < D (dsize D)"
+  by (import transc DIVISION_GT)
+
+lemma DIVISION_EQ: "division (a, b) D ==> (a = b) = (dsize D = 0)"
+  by (import transc DIVISION_EQ)
+
+lemma DIVISION_LBOUND: "division (a, b) D ==> a <= D r"
+  by (import transc DIVISION_LBOUND)
+
+lemma DIVISION_LBOUND_LT: "division (a, b) D & dsize D ~= 0 ==> a < D (Suc n)"
+  by (import transc DIVISION_LBOUND_LT)
+
+lemma DIVISION_UBOUND: "division (a, b) D ==> D r <= b"
+  by (import transc DIVISION_UBOUND)
+
+lemma DIVISION_UBOUND_LT: "division (a, b) D & n < dsize D ==> D n < b"
+  by (import transc DIVISION_UBOUND_LT)
+
+lemma DIVISION_APPEND: "(EX D1 p1. tdiv (a, b) (D1, p1) & fine g (D1, p1)) &
+(EX D2 p2. tdiv (b, c) (D2, p2) & fine g (D2, p2))
+==> EX x p. tdiv (a, c) (x, p) & fine g (x, p)"
+  by (import transc DIVISION_APPEND)
+
+lemma DIVISION_EXISTS: "a <= b & gauge (%x. a <= x & x <= b) g
+==> EX D p. tdiv (a, b) (D, p) & fine g (D, p)"
+  by (import transc DIVISION_EXISTS)
+
+lemma GAUGE_MIN: "gauge E g1 & gauge E g2 ==> gauge E (%x. if g1 x < g2 x then g1 x else g2 x)"
+  by (import transc GAUGE_MIN)
+
+lemma FINE_MIN: "fine (%x. if g1 x < g2 x then g1 x else g2 x) (D, p)
+==> fine g1 (D, p) & fine g2 (D, p)"
+  by (import transc FINE_MIN)
+
+lemma DINT_UNIQ: "a <= b & Dint (a, b) f k1 & Dint (a, b) f k2 ==> k1 = k2"
+  by (import transc DINT_UNIQ)
+
+lemma INTEGRAL_NULL: "Dint (a, a) f 0"
+  by (import transc INTEGRAL_NULL)
+
+lemma FTC1: "a <= b & (ALL x. a <= x & x <= b --> diffl f (f' x) x)
+==> Dint (a, b) f' (f b - f a)"
+  by (import transc FTC1)
+
+lemma MCLAURIN: "0 < h &
+0 < n &
+diff 0 = f &
+(ALL m t. m < n & 0 <= t & t <= h --> diffl (diff m) (diff (Suc m) t) t)
+==> EX t>0.
+       t < h &
+       f h =
+       real.sum (0, n) (%m. diff m 0 / real (FACT m) * h ^ m) +
+       diff n t / real (FACT n) * h ^ n"
+  by (import transc MCLAURIN)
+
+lemma MCLAURIN_NEG: "h < 0 &
+0 < n &
+diff 0 = f &
+(ALL m t. m < n & h <= t & t <= 0 --> diffl (diff m) (diff (Suc m) t) t)
+==> EX t>h.
+       t < 0 &
+       f h =
+       real.sum (0, n) (%m. diff m 0 / real (FACT m) * h ^ m) +
+       diff n t / real (FACT n) * h ^ n"
+  by (import transc MCLAURIN_NEG)
+
+lemma MCLAURIN_ALL_LT: "[| diff 0 = f & (ALL m x. diffl (diff m) (diff (Suc m) x) x);
+   x ~= 0 & 0 < n |]
+==> EX t. 0 < abs t &
+          abs t < abs x &
+          f x =
+          real.sum (0, n) (%m. diff m 0 / real (FACT m) * x ^ m) +
+          diff n t / real (FACT n) * x ^ n"
+  by (import transc MCLAURIN_ALL_LT)
+
+lemma MCLAURIN_ZERO: "(x::real) = (0::real) & (0::nat) < (n::nat)
+==> real.sum (0::nat, n)
+     (%m::nat.
+         (diff::nat => real => real) m (0::real) / real (FACT m) * x ^ m) =
+    diff (0::nat) (0::real)"
+  by (import transc MCLAURIN_ZERO)
+
+lemma MCLAURIN_ALL_LE: "diff 0 = f & (ALL m x. diffl (diff m) (diff (Suc m) x) x)
+==> EX t. abs t <= abs x &
+          f x =
+          real.sum (0, n) (%m. diff m 0 / real (FACT m) * x ^ m) +
+          diff n t / real (FACT n) * x ^ n"
+  by (import transc MCLAURIN_ALL_LE)
+
+lemma MCLAURIN_EXP_LT: "x ~= 0 & 0 < n
+==> EX xa.
+       0 < abs xa &
+       abs xa < abs x &
+       transc.exp x =
+       real.sum (0, n) (%m. x ^ m / real (FACT m)) +
+       transc.exp xa / real (FACT n) * x ^ n"
+  by (import transc MCLAURIN_EXP_LT)
+
+lemma MCLAURIN_EXP_LE: "EX xa.
+   abs xa <= abs x &
+   transc.exp x =
+   real.sum (0, n) (%m. x ^ m / real (FACT m)) +
+   transc.exp xa / real (FACT n) * x ^ n"
+  by (import transc MCLAURIN_EXP_LE)
+
+lemma DIFF_LN_COMPOSITE: "diffl g m x & 0 < g x ==> diffl (%x. transc.ln (g x)) (inverse (g x) * m) x"
+  by (import transc DIFF_LN_COMPOSITE)
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" poly
+
+consts
+  poly :: "real list => real => real" 
+
+specification (poly_primdef: poly) poly_def: "(ALL x. poly [] x = 0) & (ALL h t x. poly (h # t) x = h + x * poly t x)"
+  by (import poly poly_def)
+
+consts
+  poly_add :: "real list => real list => real list" 
+
+specification (poly_add_primdef: poly_add) poly_add_def: "(ALL l2. poly_add [] l2 = l2) &
+(ALL h t l2.
+    poly_add (h # t) l2 =
+    (if l2 = [] then h # t else (h + hd l2) # poly_add t (tl l2)))"
+  by (import poly poly_add_def)
+
+consts
+  "##" :: "real => real list => real list" ("##")
+
+specification ("##") poly_cmul_def: "(ALL c. ## c [] = []) & (ALL c h t. ## c (h # t) = c * h # ## c t)"
+  by (import poly poly_cmul_def)
+
+consts
+  poly_neg :: "real list => real list" 
+
+defs
+  poly_neg_primdef: "poly_neg == ## (- 1)"
+
+lemma poly_neg_def: "poly_neg = ## (- 1)"
+  by (import poly poly_neg_def)
+
+consts
+  poly_mul :: "real list => real list => real list" 
+
+specification (poly_mul_primdef: poly_mul) poly_mul_def: "(ALL l2. poly_mul [] l2 = []) &
+(ALL h t l2.
+    poly_mul (h # t) l2 =
+    (if t = [] then ## h l2 else poly_add (## h l2) (0 # poly_mul t l2)))"
+  by (import poly poly_mul_def)
+
+consts
+  poly_exp :: "real list => nat => real list" 
+
+specification (poly_exp_primdef: poly_exp) poly_exp_def: "(ALL p. poly_exp p 0 = [1]) &
+(ALL p n. poly_exp p (Suc n) = poly_mul p (poly_exp p n))"
+  by (import poly poly_exp_def)
+
+consts
+  poly_diff_aux :: "nat => real list => real list" 
+
+specification (poly_diff_aux_primdef: poly_diff_aux) poly_diff_aux_def: "(ALL n. poly_diff_aux n [] = []) &
+(ALL n h t. poly_diff_aux n (h # t) = real n * h # poly_diff_aux (Suc n) t)"
+  by (import poly poly_diff_aux_def)
+
+definition
+  diff :: "real list => real list"  where
+  "diff == %l. if l = [] then [] else poly_diff_aux 1 (tl l)"
+
+lemma poly_diff_def: "diff l = (if l = [] then [] else poly_diff_aux 1 (tl l))"
+  by (import poly poly_diff_def)
+
+lemma POLY_ADD_CLAUSES: "poly_add [] p2 = p2 &
+poly_add p1 [] = p1 &
+poly_add (h1 # t1) (h2 # t2) = (h1 + h2) # poly_add t1 t2"
+  by (import poly POLY_ADD_CLAUSES)
+
+lemma POLY_CMUL_CLAUSES: "## c [] = [] & ## c (h # t) = c * h # ## c t"
+  by (import poly POLY_CMUL_CLAUSES)
+
+lemma POLY_NEG_CLAUSES: "poly_neg [] = [] & poly_neg (h # t) = - h # poly_neg t"
+  by (import poly POLY_NEG_CLAUSES)
+
+lemma POLY_MUL_CLAUSES: "poly_mul [] p2 = [] &
+poly_mul [h1] p2 = ## h1 p2 &
+poly_mul (h1 # k1 # t1) p2 = poly_add (## h1 p2) (0 # poly_mul (k1 # t1) p2)"
+  by (import poly POLY_MUL_CLAUSES)
+
+lemma POLY_DIFF_CLAUSES: "diff [] = [] & diff [c] = [] & diff (h # t) = poly_diff_aux 1 t"
+  by (import poly POLY_DIFF_CLAUSES)
+
+lemma POLY_ADD: "poly (poly_add t p2) x = poly t x + poly p2 x"
+  by (import poly POLY_ADD)
+
+lemma POLY_CMUL: "poly (## c t) x = c * poly t x"
+  by (import poly POLY_CMUL)
+
+lemma POLY_NEG: "poly (poly_neg x) xa = - poly x xa"
+  by (import poly POLY_NEG)
+
+lemma POLY_MUL: "poly (poly_mul t p2) x = poly t x * poly p2 x"
+  by (import poly POLY_MUL)
+
+lemma POLY_EXP: "poly (poly_exp p n) x = poly p x ^ n"
+  by (import poly POLY_EXP)
+
+lemma POLY_DIFF_LEMMA: "diffl (%x. x ^ Suc n * poly t x) (x ^ n * poly (poly_diff_aux (Suc n) t) x)
+ x"
+  by (import poly POLY_DIFF_LEMMA)
+
+lemma POLY_DIFF: "diffl (poly t) (poly (diff t) x) x"
+  by (import poly POLY_DIFF)
+
+lemma POLY_DIFFERENTIABLE: "lim.differentiable (poly l) x"
+  by (import poly POLY_DIFFERENTIABLE)
+
+lemma POLY_CONT: "contl (poly l) x"
+  by (import poly POLY_CONT)
+
+lemma POLY_IVT_POS: "xa < xb & poly x xa < 0 & 0 < poly x xb
+==> EX xc>xa. xc < xb & poly x xc = 0"
+  by (import poly POLY_IVT_POS)
+
+lemma POLY_IVT_NEG: "a < b & 0 < poly p a & poly p b < 0 ==> EX x>a. x < b & poly p x = 0"
+  by (import poly POLY_IVT_NEG)
+
+lemma POLY_MVT: "a < b ==> EX x>a. x < b & poly p b - poly p a = (b - a) * poly (diff p) x"
+  by (import poly POLY_MVT)
+
+lemma POLY_ADD_RZERO: "poly (poly_add x []) = poly x"
+  by (import poly POLY_ADD_RZERO)
+
+lemma POLY_MUL_ASSOC: "poly (poly_mul x (poly_mul xa xb)) = poly (poly_mul (poly_mul x xa) xb)"
+  by (import poly POLY_MUL_ASSOC)
+
+lemma POLY_EXP_ADD: "poly (poly_exp xb (xa + x)) =
+poly (poly_mul (poly_exp xb xa) (poly_exp xb x))"
+  by (import poly POLY_EXP_ADD)
+
+lemma POLY_DIFF_AUX_ADD: "poly (poly_diff_aux n (poly_add t p2)) =
+poly (poly_add (poly_diff_aux n t) (poly_diff_aux n p2))"
+  by (import poly POLY_DIFF_AUX_ADD)
+
+lemma POLY_DIFF_AUX_CMUL: "poly (poly_diff_aux n (## c t)) = poly (## c (poly_diff_aux n t))"
+  by (import poly POLY_DIFF_AUX_CMUL)
+
+lemma POLY_DIFF_AUX_NEG: "poly (poly_diff_aux xa (poly_neg x)) = poly (poly_neg (poly_diff_aux xa x))"
+  by (import poly POLY_DIFF_AUX_NEG)
+
+lemma POLY_DIFF_AUX_MUL_LEMMA: "poly (poly_diff_aux (Suc n) t) = poly (poly_add (poly_diff_aux n t) t)"
+  by (import poly POLY_DIFF_AUX_MUL_LEMMA)
+
+lemma POLY_DIFF_ADD: "poly (diff (poly_add t p2)) = poly (poly_add (diff t) (diff p2))"
+  by (import poly POLY_DIFF_ADD)
+
+lemma POLY_DIFF_CMUL: "poly (diff (## c t)) = poly (## c (diff t))"
+  by (import poly POLY_DIFF_CMUL)
+
+lemma POLY_DIFF_NEG: "poly (diff (poly_neg x)) = poly (poly_neg (diff x))"
+  by (import poly POLY_DIFF_NEG)
+
+lemma POLY_DIFF_MUL_LEMMA: "poly (diff (xa # x)) = poly (poly_add (0 # diff x) x)"
+  by (import poly POLY_DIFF_MUL_LEMMA)
+
+lemma POLY_DIFF_MUL: "poly (diff (poly_mul t p2)) =
+poly (poly_add (poly_mul t (diff p2)) (poly_mul (diff t) p2))"
+  by (import poly POLY_DIFF_MUL)
+
+lemma POLY_DIFF_EXP: "poly (diff (poly_exp p (Suc n))) =
+poly (poly_mul (## (real (Suc n)) (poly_exp p n)) (diff p))"
+  by (import poly POLY_DIFF_EXP)
+
+lemma POLY_DIFF_EXP_PRIME: "poly (diff (poly_exp [- a, 1] (Suc n))) =
+poly (## (real (Suc n)) (poly_exp [- a, 1] n))"
+  by (import poly POLY_DIFF_EXP_PRIME)
+
+lemma POLY_LINEAR_REM: "EX q r. h # t = poly_add [r] (poly_mul [- a, 1] q)"
+  by (import poly POLY_LINEAR_REM)
+
+lemma POLY_LINEAR_DIVIDES: "(poly t a = 0) = (t = [] | (EX q. t = poly_mul [- a, 1] q))"
+  by (import poly POLY_LINEAR_DIVIDES)
+
+lemma POLY_LENGTH_MUL: "length (poly_mul [- a, 1] x) = Suc (length x)"
+  by (import poly POLY_LENGTH_MUL)
+
+lemma POLY_ROOTS_INDEX_LEMMA: "poly p ~= poly [] & length p = n
+==> EX i. ALL x. poly p x = 0 --> (EX m<=n. x = i m)"
+  by (import poly POLY_ROOTS_INDEX_LEMMA)
+
+lemma POLY_ROOTS_INDEX_LENGTH: "poly p ~= poly []
+==> EX i. ALL x. poly p x = 0 --> (EX n<=length p. x = i n)"
+  by (import poly POLY_ROOTS_INDEX_LENGTH)
+
+lemma POLY_ROOTS_FINITE_LEMMA: "poly (p::real list) ~= poly []
+==> EX (N::nat) i::nat => real.
+       ALL x::real. poly p x = (0::real) --> (EX n<N. x = i n)"
+  by (import poly POLY_ROOTS_FINITE_LEMMA)
+
+lemma FINITE_LEMMA: "(!!xb::real. (xa::real => bool) xb ==> EX n<x::nat. xb = (i::nat => real) n)
+==> EX a::real. ALL x::real. xa x --> x < a"
+  by (import poly FINITE_LEMMA)
+
+lemma POLY_ROOTS_FINITE: "(poly (p::real list) ~= poly []) =
+(EX (N::nat) i::nat => real.
+    ALL x::real. poly p x = (0::real) --> (EX n<N. x = i n))"
+  by (import poly POLY_ROOTS_FINITE)
+
+lemma POLY_ENTIRE_LEMMA: "poly p ~= poly [] & poly q ~= poly [] ==> poly (poly_mul p q) ~= poly []"
+  by (import poly POLY_ENTIRE_LEMMA)
+
+lemma POLY_ENTIRE: "(poly (poly_mul p q) = poly []) = (poly p = poly [] | poly q = poly [])"
+  by (import poly POLY_ENTIRE)
+
+lemma POLY_MUL_LCANCEL: "(poly (poly_mul x xa) = poly (poly_mul x xb)) =
+(poly x = poly [] | poly xa = poly xb)"
+  by (import poly POLY_MUL_LCANCEL)
+
+lemma POLY_EXP_EQ_0: "(poly (poly_exp p n) = poly []) = (poly p = poly [] & n ~= 0)"
+  by (import poly POLY_EXP_EQ_0)
+
+lemma POLY_PRIME_EQ_0: "poly [a, 1] ~= poly []"
+  by (import poly POLY_PRIME_EQ_0)
+
+lemma POLY_EXP_PRIME_EQ_0: "poly (poly_exp [a, 1] n) ~= poly []"
+  by (import poly POLY_EXP_PRIME_EQ_0)
+
+lemma POLY_ZERO_LEMMA: "poly (h # t) = poly [] ==> h = 0 & poly t = poly []"
+  by (import poly POLY_ZERO_LEMMA)
+
+lemma POLY_ZERO: "(poly t = poly []) = list_all (%c. c = 0) t"
+  by (import poly POLY_ZERO)
+
+lemma POLY_DIFF_AUX_ISZERO: "list_all (%c. c = 0) (poly_diff_aux (Suc n) t) = list_all (%c. c = 0) t"
+  by (import poly POLY_DIFF_AUX_ISZERO)
+
+lemma POLY_DIFF_ISZERO: "poly (diff x) = poly [] ==> EX h. poly x = poly [h]"
+  by (import poly POLY_DIFF_ISZERO)
+
+lemma POLY_DIFF_ZERO: "poly x = poly [] ==> poly (diff x) = poly []"
+  by (import poly POLY_DIFF_ZERO)
+
+lemma POLY_DIFF_WELLDEF: "poly p = poly q ==> poly (diff p) = poly (diff q)"
+  by (import poly POLY_DIFF_WELLDEF)
+
+definition
+  poly_divides :: "real list => real list => bool"  where
+  "poly_divides == %p1 p2. EX q. poly p2 = poly (poly_mul p1 q)"
+
+lemma poly_divides: "poly_divides p1 p2 = (EX q. poly p2 = poly (poly_mul p1 q))"
+  by (import poly poly_divides)
+
+lemma POLY_PRIMES: "poly_divides [a, 1] (poly_mul p q) =
+(poly_divides [a, 1] p | poly_divides [a, 1] q)"
+  by (import poly POLY_PRIMES)
+
+lemma POLY_DIVIDES_REFL: "poly_divides p p"
+  by (import poly POLY_DIVIDES_REFL)
+
+lemma POLY_DIVIDES_TRANS: "poly_divides p q & poly_divides q r ==> poly_divides p r"
+  by (import poly POLY_DIVIDES_TRANS)
+
+lemma POLY_DIVIDES_EXP: "m <= n ==> poly_divides (poly_exp p m) (poly_exp p n)"
+  by (import poly POLY_DIVIDES_EXP)
+
+lemma POLY_EXP_DIVIDES: "poly_divides (poly_exp p n) q & m <= n ==> poly_divides (poly_exp p m) q"
+  by (import poly POLY_EXP_DIVIDES)
+
+lemma POLY_DIVIDES_ADD: "poly_divides p q & poly_divides p r ==> poly_divides p (poly_add q r)"
+  by (import poly POLY_DIVIDES_ADD)
+
+lemma POLY_DIVIDES_SUB: "poly_divides p q & poly_divides p (poly_add q r) ==> poly_divides p r"
+  by (import poly POLY_DIVIDES_SUB)
+
+lemma POLY_DIVIDES_SUB2: "poly_divides p r & poly_divides p (poly_add q r) ==> poly_divides p q"
+  by (import poly POLY_DIVIDES_SUB2)
+
+lemma POLY_DIVIDES_ZERO: "poly p = poly [] ==> poly_divides q p"
+  by (import poly POLY_DIVIDES_ZERO)
+
+lemma POLY_ORDER_EXISTS: "length p = d & poly p ~= poly []
+==> EX x. poly_divides (poly_exp [- a, 1] x) p &
+          ~ poly_divides (poly_exp [- a, 1] (Suc x)) p"
+  by (import poly POLY_ORDER_EXISTS)
+
+lemma POLY_ORDER: "poly p ~= poly []
+==> EX! n.
+       poly_divides (poly_exp [- a, 1] n) p &
+       ~ poly_divides (poly_exp [- a, 1] (Suc n)) p"
+  by (import poly POLY_ORDER)
+
+definition
+  poly_order :: "real => real list => nat"  where
+  "poly_order ==
+%a p. SOME n.
+         poly_divides (poly_exp [- a, 1] n) p &
+         ~ poly_divides (poly_exp [- a, 1] (Suc n)) p"
+
+lemma poly_order: "poly_order a p =
+(SOME n.
+    poly_divides (poly_exp [- a, 1] n) p &
+    ~ poly_divides (poly_exp [- a, 1] (Suc n)) p)"
+  by (import poly poly_order)
+
+lemma ORDER: "(poly_divides (poly_exp [- a, 1] n) p &
+ ~ poly_divides (poly_exp [- a, 1] (Suc n)) p) =
+(n = poly_order a p & poly p ~= poly [])"
+  by (import poly ORDER)
+
+lemma ORDER_THM: "poly p ~= poly []
+==> poly_divides (poly_exp [- a, 1] (poly_order a p)) p &
+    ~ poly_divides (poly_exp [- a, 1] (Suc (poly_order a p))) p"
+  by (import poly ORDER_THM)
+
+lemma ORDER_UNIQUE: "poly p ~= poly [] &
+poly_divides (poly_exp [- a, 1] n) p &
+~ poly_divides (poly_exp [- a, 1] (Suc n)) p
+==> n = poly_order a p"
+  by (import poly ORDER_UNIQUE)
+
+lemma ORDER_POLY: "poly p = poly q ==> poly_order a p = poly_order a q"
+  by (import poly ORDER_POLY)
+
+lemma ORDER_ROOT: "(poly p a = 0) = (poly p = poly [] | poly_order a p ~= 0)"
+  by (import poly ORDER_ROOT)
+
+lemma ORDER_DIVIDES: "poly_divides (poly_exp [- a, 1] n) p =
+(poly p = poly [] | n <= poly_order a p)"
+  by (import poly ORDER_DIVIDES)
+
+lemma ORDER_DECOMP: "poly p ~= poly []
+==> EX x. poly p = poly (poly_mul (poly_exp [- a, 1] (poly_order a p)) x) &
+          ~ poly_divides [- a, 1] x"
+  by (import poly ORDER_DECOMP)
+
+lemma ORDER_MUL: "poly (poly_mul p q) ~= poly []
+==> poly_order a (poly_mul p q) = poly_order a p + poly_order a q"
+  by (import poly ORDER_MUL)
+
+lemma ORDER_DIFF: "poly (diff p) ~= poly [] & poly_order a p ~= 0
+==> poly_order a p = Suc (poly_order a (diff p))"
+  by (import poly ORDER_DIFF)
+
+lemma POLY_SQUAREFREE_DECOMP_ORDER: "poly (diff p) ~= poly [] &
+poly p = poly (poly_mul q d) &
+poly (diff p) = poly (poly_mul e d) &
+poly d = poly (poly_add (poly_mul r p) (poly_mul s (diff p)))
+==> poly_order a q = (if poly_order a p = 0 then 0 else 1)"
+  by (import poly POLY_SQUAREFREE_DECOMP_ORDER)
+
+definition
+  rsquarefree :: "real list => bool"  where
+  "rsquarefree ==
+%p. poly p ~= poly [] & (ALL a. poly_order a p = 0 | poly_order a p = 1)"
+
+lemma rsquarefree: "rsquarefree p =
+(poly p ~= poly [] & (ALL a. poly_order a p = 0 | poly_order a p = 1))"
+  by (import poly rsquarefree)
+
+lemma RSQUAREFREE_ROOTS: "rsquarefree p = (ALL a. ~ (poly p a = 0 & poly (diff p) a = 0))"
+  by (import poly RSQUAREFREE_ROOTS)
+
+lemma RSQUAREFREE_DECOMP: "rsquarefree p & poly p a = 0
+==> EX q. poly p = poly (poly_mul [- a, 1] q) & poly q a ~= 0"
+  by (import poly RSQUAREFREE_DECOMP)
+
+lemma POLY_SQUAREFREE_DECOMP: "poly (diff p) ~= poly [] &
+poly p = poly (poly_mul q d) &
+poly (diff p) = poly (poly_mul e d) &
+poly d = poly (poly_add (poly_mul r p) (poly_mul s (diff p)))
+==> rsquarefree q & (ALL x. (poly q x = 0) = (poly p x = 0))"
+  by (import poly POLY_SQUAREFREE_DECOMP)
+
+consts
+  normalize :: "real list => real list" 
+
+specification (normalize) normalize: "normalize [] = [] &
+(ALL h t.
+    normalize (h # t) =
+    (if normalize t = [] then if h = 0 then [] else [h]
+     else h # normalize t))"
+  by (import poly normalize)
+
+lemma POLY_NORMALIZE: "poly (normalize t) = poly t"
+  by (import poly POLY_NORMALIZE)
+
+definition
+  degree :: "real list => nat"  where
+  "degree == %p. PRE (length (normalize p))"
+
+lemma degree: "degree p = PRE (length (normalize p))"
+  by (import poly degree)
+
+lemma DEGREE_ZERO: "poly p = poly [] ==> degree p = 0"
+  by (import poly DEGREE_ZERO)
+
+lemma POLY_ROOTS_FINITE_SET: "poly p ~= poly [] ==> FINITE (GSPEC (%x. (x, poly p x = 0)))"
+  by (import poly POLY_ROOTS_FINITE_SET)
+
+lemma POLY_MONO: "abs x <= k ==> abs (poly xa x) <= poly (map abs xa) k"
+  by (import poly POLY_MONO)
+
+;end_setup
+
+end
+
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/HOL4Vec.thy
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/HOL4Vec.thy	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,1105 @@
+(* AUTOMATICALLY GENERATED, DO NOT EDIT! *)
+
+theory HOL4Vec imports HOL4Base begin
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" res_quan
+
+lemma RES_FORALL_CONJ_DIST: "RES_FORALL P (%i. Q i & R i) = (RES_FORALL P Q & RES_FORALL P R)"
+  by (import res_quan RES_FORALL_CONJ_DIST)
+
+lemma RES_FORALL_DISJ_DIST: "RES_FORALL (%j. P j | Q j) R = (RES_FORALL P R & RES_FORALL Q R)"
+  by (import res_quan RES_FORALL_DISJ_DIST)
+
+lemma RES_FORALL_UNIQUE: "RES_FORALL (op = xa) x = x xa"
+  by (import res_quan RES_FORALL_UNIQUE)
+
+lemma RES_FORALL_FORALL: "(ALL x::'b.
+    RES_FORALL (P::'a => bool) (%i::'a. (R::'a => 'b => bool) i x)) =
+RES_FORALL P (%i::'a. All (R i))"
+  by (import res_quan RES_FORALL_FORALL)
+
+lemma RES_FORALL_REORDER: "RES_FORALL P (%i. RES_FORALL Q (R i)) =
+RES_FORALL Q (%j. RES_FORALL P (%i. R i j))"
+  by (import res_quan RES_FORALL_REORDER)
+
+lemma RES_FORALL_EMPTY: "RES_FORALL EMPTY x"
+  by (import res_quan RES_FORALL_EMPTY)
+
+lemma RES_FORALL_UNIV: "RES_FORALL pred_set.UNIV p = All p"
+  by (import res_quan RES_FORALL_UNIV)
+
+lemma RES_FORALL_NULL: "RES_FORALL p (%x. m) = (p = EMPTY | m)"
+  by (import res_quan RES_FORALL_NULL)
+
+lemma RES_EXISTS_DISJ_DIST: "RES_EXISTS P (%i. Q i | R i) = (RES_EXISTS P Q | RES_EXISTS P R)"
+  by (import res_quan RES_EXISTS_DISJ_DIST)
+
+lemma RES_DISJ_EXISTS_DIST: "RES_EXISTS (%i. P i | Q i) R = (RES_EXISTS P R | RES_EXISTS Q R)"
+  by (import res_quan RES_DISJ_EXISTS_DIST)
+
+lemma RES_EXISTS_EQUAL: "RES_EXISTS (op = xa) x = x xa"
+  by (import res_quan RES_EXISTS_EQUAL)
+
+lemma RES_EXISTS_REORDER: "RES_EXISTS P (%i. RES_EXISTS Q (R i)) =
+RES_EXISTS Q (%j. RES_EXISTS P (%i. R i j))"
+  by (import res_quan RES_EXISTS_REORDER)
+
+lemma RES_EXISTS_EMPTY: "~ RES_EXISTS EMPTY p"
+  by (import res_quan RES_EXISTS_EMPTY)
+
+lemma RES_EXISTS_UNIV: "RES_EXISTS pred_set.UNIV p = Ex p"
+  by (import res_quan RES_EXISTS_UNIV)
+
+lemma RES_EXISTS_NULL: "RES_EXISTS p (%x. m) = (p ~= EMPTY & m)"
+  by (import res_quan RES_EXISTS_NULL)
+
+lemma RES_EXISTS_ALT: "RES_EXISTS p m = (IN (RES_SELECT p m) p & m (RES_SELECT p m))"
+  by (import res_quan RES_EXISTS_ALT)
+
+lemma RES_EXISTS_UNIQUE_EMPTY: "~ RES_EXISTS_UNIQUE EMPTY p"
+  by (import res_quan RES_EXISTS_UNIQUE_EMPTY)
+
+lemma RES_EXISTS_UNIQUE_UNIV: "RES_EXISTS_UNIQUE pred_set.UNIV p = Ex1 p"
+  by (import res_quan RES_EXISTS_UNIQUE_UNIV)
+
+lemma RES_EXISTS_UNIQUE_NULL: "RES_EXISTS_UNIQUE p (%x. m) = ((EX x. p = INSERT x EMPTY) & m)"
+  by (import res_quan RES_EXISTS_UNIQUE_NULL)
+
+lemma RES_EXISTS_UNIQUE_ALT: "RES_EXISTS_UNIQUE p m =
+RES_EXISTS p (%x. m x & RES_FORALL p (%y. m y --> y = x))"
+  by (import res_quan RES_EXISTS_UNIQUE_ALT)
+
+lemma RES_SELECT_EMPTY: "RES_SELECT EMPTY p = (SOME x. False)"
+  by (import res_quan RES_SELECT_EMPTY)
+
+lemma RES_SELECT_UNIV: "RES_SELECT pred_set.UNIV p = Eps p"
+  by (import res_quan RES_SELECT_UNIV)
+
+lemma RES_ABSTRACT: "IN x p ==> RES_ABSTRACT p m x = m x"
+  by (import res_quan RES_ABSTRACT)
+
+lemma RES_ABSTRACT_EQUAL: "(!!x. IN x p ==> m1 x = m2 x) ==> RES_ABSTRACT p m1 = RES_ABSTRACT p m2"
+  by (import res_quan RES_ABSTRACT_EQUAL)
+
+lemma RES_ABSTRACT_IDEMPOT: "RES_ABSTRACT p (RES_ABSTRACT p m) = RES_ABSTRACT p m"
+  by (import res_quan RES_ABSTRACT_IDEMPOT)
+
+lemma RES_ABSTRACT_EQUAL_EQ: "(RES_ABSTRACT p m1 = RES_ABSTRACT p m2) = (ALL x. IN x p --> m1 x = m2 x)"
+  by (import res_quan RES_ABSTRACT_EQUAL_EQ)
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" word_base
+
+typedef (open) ('a) word = "{x. ALL word.
+       (ALL a0. (EX a. a0 = CONSTR 0 a (%n. BOTTOM)) --> word a0) -->
+       word x} :: ('a::type list recspace set)"
+  by (rule typedef_helper,import word_base word_TY_DEF)
+
+lemmas word_TY_DEF = typedef_hol2hol4 [OF type_definition_word]
+
+consts
+  mk_word :: "'a list recspace => 'a word" 
+  dest_word :: "'a word => 'a list recspace" 
+
+specification (dest_word mk_word) word_repfns: "(ALL a::'a word. mk_word (dest_word a) = a) &
+(ALL r::'a list recspace.
+    (ALL word::'a list recspace => bool.
+        (ALL a0::'a list recspace.
+            (EX a::'a list. a0 = CONSTR (0::nat) a (%n::nat. BOTTOM)) -->
+            word a0) -->
+        word r) =
+    (dest_word (mk_word r) = r))"
+  by (import word_base word_repfns)
+
+consts
+  word_base0 :: "'a list => 'a word" 
+
+defs
+  word_base0_primdef: "word_base0 == %a. mk_word (CONSTR 0 a (%n. BOTTOM))"
+
+lemma word_base0_def: "word_base0 = (%a. mk_word (CONSTR 0 a (%n. BOTTOM)))"
+  by (import word_base word_base0_def)
+
+definition
+  WORD :: "'a list => 'a word"  where
+  "WORD == word_base0"
+
+lemma WORD: "WORD = word_base0"
+  by (import word_base WORD)
+
+consts
+  word_case :: "('a list => 'b) => 'a word => 'b" 
+
+specification (word_case_primdef: word_case) word_case_def: "ALL f a. word_base.word_case f (WORD a) = f a"
+  by (import word_base word_case_def)
+
+consts
+  word_size :: "('a => nat) => 'a word => nat" 
+
+specification (word_size_primdef: word_size) word_size_def: "ALL f a. word_base.word_size f (WORD a) = 1 + Compatibility.list_size f a"
+  by (import word_base word_size_def)
+
+lemma word_11: "(WORD a = WORD a') = (a = a')"
+  by (import word_base word_11)
+
+lemma word_case_cong: "M = M' & (ALL a. M' = WORD a --> f a = f' a)
+==> word_base.word_case f M = word_base.word_case f' M'"
+  by (import word_base word_case_cong)
+
+lemma word_nchotomy: "EX l. x = WORD l"
+  by (import word_base word_nchotomy)
+
+lemma word_Axiom: "EX fn. ALL a. fn (WORD a) = f a"
+  by (import word_base word_Axiom)
+
+lemma word_induction: "(!!a. P (WORD a)) ==> P x"
+  by (import word_base word_induction)
+
+lemma word_Ax: "EX fn. ALL a. fn (WORD a) = f a"
+  by (import word_base word_Ax)
+
+lemma WORD_11: "(WORD x = WORD xa) = (x = xa)"
+  by (import word_base WORD_11)
+
+lemma word_induct: "(!!l. x (WORD l)) ==> x xa"
+  by (import word_base word_induct)
+
+lemma word_cases: "EX l. x = WORD l"
+  by (import word_base word_cases)
+
+consts
+  WORDLEN :: "'a word => nat" 
+
+specification (WORDLEN) WORDLEN_DEF: "ALL l. WORDLEN (WORD l) = length l"
+  by (import word_base WORDLEN_DEF)
+
+consts
+  PWORDLEN :: "nat => 'a word => bool" 
+
+defs
+  PWORDLEN_primdef: "PWORDLEN == %n. GSPEC (%w. (w, WORDLEN w = n))"
+
+lemma PWORDLEN_def: "PWORDLEN n = GSPEC (%w. (w, WORDLEN w = n))"
+  by (import word_base PWORDLEN_def)
+
+lemma IN_PWORDLEN: "IN (WORD l) (PWORDLEN n) = (length l = n)"
+  by (import word_base IN_PWORDLEN)
+
+lemma PWORDLEN: "IN w (PWORDLEN n) = (WORDLEN w = n)"
+  by (import word_base PWORDLEN)
+
+lemma PWORDLEN0: "IN w (PWORDLEN 0) ==> w = WORD []"
+  by (import word_base PWORDLEN0)
+
+lemma PWORDLEN1: "IN (WORD [x]) (PWORDLEN 1)"
+  by (import word_base PWORDLEN1)
+
+consts
+  WSEG :: "nat => nat => 'a word => 'a word" 
+
+specification (WSEG) WSEG_DEF: "ALL m k l. WSEG m k (WORD l) = WORD (LASTN m (BUTLASTN k l))"
+  by (import word_base WSEG_DEF)
+
+lemma WSEG0: "WSEG 0 k w = WORD []"
+  by (import word_base WSEG0)
+
+lemma WSEG_PWORDLEN: "RES_FORALL (PWORDLEN n)
+ (%w. ALL m k. m + k <= n --> IN (WSEG m k w) (PWORDLEN m))"
+  by (import word_base WSEG_PWORDLEN)
+
+lemma WSEG_WORDLEN: "RES_FORALL (PWORDLEN x)
+ (%xa. ALL xb xc. xb + xc <= x --> WORDLEN (WSEG xb xc xa) = xb)"
+  by (import word_base WSEG_WORDLEN)
+
+lemma WSEG_WORD_LENGTH: "RES_FORALL (PWORDLEN n) (%w. WSEG n 0 w = w)"
+  by (import word_base WSEG_WORD_LENGTH)
+
+consts
+  bit :: "nat => 'a word => 'a" 
+
+specification (bit) BIT_DEF: "ALL k l. bit k (WORD l) = ELL k l"
+  by (import word_base BIT_DEF)
+
+lemma BIT0: "bit 0 (WORD [x]) = x"
+  by (import word_base BIT0)
+
+lemma WSEG_BIT: "RES_FORALL (PWORDLEN n) (%w. ALL k<n. WSEG 1 k w = WORD [bit k w])"
+  by (import word_base WSEG_BIT)
+
+lemma BIT_WSEG: "RES_FORALL (PWORDLEN n)
+ (%w. ALL m k j.
+         m + k <= n --> j < m --> bit j (WSEG m k w) = bit (j + k) w)"
+  by (import word_base BIT_WSEG)
+
+consts
+  MSB :: "'a word => 'a" 
+
+specification (MSB) MSB_DEF: "ALL l. MSB (WORD l) = hd l"
+  by (import word_base MSB_DEF)
+
+lemma MSB: "RES_FORALL (PWORDLEN n) (%w. 0 < n --> MSB w = bit (PRE n) w)"
+  by (import word_base MSB)
+
+consts
+  LSB :: "'a word => 'a" 
+
+specification (LSB) LSB_DEF: "ALL l. LSB (WORD l) = last l"
+  by (import word_base LSB_DEF)
+
+lemma LSB: "RES_FORALL (PWORDLEN n) (%w. 0 < n --> LSB w = bit 0 w)"
+  by (import word_base LSB)
+
+consts
+  WSPLIT :: "nat => 'a word => 'a word * 'a word" 
+
+specification (WSPLIT) WSPLIT_DEF: "ALL m l. WSPLIT m (WORD l) = (WORD (BUTLASTN m l), WORD (LASTN m l))"
+  by (import word_base WSPLIT_DEF)
+
+consts
+  WCAT :: "'a word * 'a word => 'a word" 
+
+specification (WCAT) WCAT_DEF: "ALL l1 l2. WCAT (WORD l1, WORD l2) = WORD (l1 @ l2)"
+  by (import word_base WCAT_DEF)
+
+lemma WORD_PARTITION: "(ALL n::nat.
+    RES_FORALL (PWORDLEN n)
+     (%w::'a word. ALL m<=n. WCAT (WSPLIT m w) = w)) &
+(ALL (n::nat) m::nat.
+    RES_FORALL (PWORDLEN n)
+     (%w1::'a word.
+         RES_FORALL (PWORDLEN m)
+          (%w2::'a word. WSPLIT m (WCAT (w1, w2)) = (w1, w2))))"
+  by (import word_base WORD_PARTITION)
+
+lemma WCAT_ASSOC: "WCAT (w1, WCAT (w2, w3)) = WCAT (WCAT (w1, w2), w3)"
+  by (import word_base WCAT_ASSOC)
+
+lemma WCAT0: "WCAT (WORD [], w) = w & WCAT (w, WORD []) = w"
+  by (import word_base WCAT0)
+
+lemma WCAT_11: "RES_FORALL (PWORDLEN m)
+ (%wm1. RES_FORALL (PWORDLEN m)
+         (%wm2. RES_FORALL (PWORDLEN n)
+                 (%wn1. RES_FORALL (PWORDLEN n)
+                         (%wn2. (WCAT (wm1, wn1) = WCAT (wm2, wn2)) =
+                                (wm1 = wm2 & wn1 = wn2)))))"
+  by (import word_base WCAT_11)
+
+lemma WSPLIT_PWORDLEN: "RES_FORALL (PWORDLEN n)
+ (%w. ALL m<=n.
+         IN (fst (WSPLIT m w)) (PWORDLEN (n - m)) &
+         IN (snd (WSPLIT m w)) (PWORDLEN m))"
+  by (import word_base WSPLIT_PWORDLEN)
+
+lemma WCAT_PWORDLEN: "RES_FORALL (PWORDLEN n1)
+ (%w1. ALL n2.
+          RES_FORALL (PWORDLEN n2)
+           (%w2. IN (WCAT (w1, w2)) (PWORDLEN (n1 + n2))))"
+  by (import word_base WCAT_PWORDLEN)
+
+lemma WORDLEN_SUC_WCAT: "IN w (PWORDLEN (Suc n))
+==> RES_EXISTS (PWORDLEN 1)
+     (%b. RES_EXISTS (PWORDLEN n) (%w'. w = WCAT (b, w')))"
+  by (import word_base WORDLEN_SUC_WCAT)
+
+lemma WSEG_WSEG: "RES_FORALL (PWORDLEN n)
+ (%w. ALL m1 k1 m2 k2.
+         m1 + k1 <= n & m2 + k2 <= m1 -->
+         WSEG m2 k2 (WSEG m1 k1 w) = WSEG m2 (k1 + k2) w)"
+  by (import word_base WSEG_WSEG)
+
+lemma WSPLIT_WSEG: "RES_FORALL (PWORDLEN n)
+ (%w. ALL k<=n. WSPLIT k w = (WSEG (n - k) k w, WSEG k 0 w))"
+  by (import word_base WSPLIT_WSEG)
+
+lemma WSPLIT_WSEG1: "RES_FORALL (PWORDLEN n) (%w. ALL k<=n. fst (WSPLIT k w) = WSEG (n - k) k w)"
+  by (import word_base WSPLIT_WSEG1)
+
+lemma WSPLIT_WSEG2: "RES_FORALL (PWORDLEN n) (%w. ALL k<=n. snd (WSPLIT k w) = WSEG k 0 w)"
+  by (import word_base WSPLIT_WSEG2)
+
+lemma WCAT_WSEG_WSEG: "RES_FORALL (PWORDLEN n)
+ (%w. ALL m1 m2 k.
+         m1 + (m2 + k) <= n -->
+         WCAT (WSEG m2 (m1 + k) w, WSEG m1 k w) = WSEG (m1 + m2) k w)"
+  by (import word_base WCAT_WSEG_WSEG)
+
+lemma WORD_SPLIT: "RES_FORALL (PWORDLEN (x + xa)) (%w. w = WCAT (WSEG x xa w, WSEG xa 0 w))"
+  by (import word_base WORD_SPLIT)
+
+lemma WORDLEN_SUC_WCAT_WSEG_WSEG: "RES_FORALL (PWORDLEN (Suc n)) (%w. w = WCAT (WSEG 1 n w, WSEG n 0 w))"
+  by (import word_base WORDLEN_SUC_WCAT_WSEG_WSEG)
+
+lemma WORDLEN_SUC_WCAT_WSEG_WSEG_RIGHT: "RES_FORALL (PWORDLEN (Suc n)) (%w. w = WCAT (WSEG n 1 w, WSEG 1 0 w))"
+  by (import word_base WORDLEN_SUC_WCAT_WSEG_WSEG_RIGHT)
+
+lemma WORDLEN_SUC_WCAT_BIT_WSEG: "RES_FORALL (PWORDLEN (Suc n)) (%w. w = WCAT (WORD [bit n w], WSEG n 0 w))"
+  by (import word_base WORDLEN_SUC_WCAT_BIT_WSEG)
+
+lemma WORDLEN_SUC_WCAT_BIT_WSEG_RIGHT: "RES_FORALL (PWORDLEN (Suc n)) (%w. w = WCAT (WSEG n 1 w, WORD [bit 0 w]))"
+  by (import word_base WORDLEN_SUC_WCAT_BIT_WSEG_RIGHT)
+
+lemma WSEG_WCAT1: "RES_FORALL (PWORDLEN n1)
+ (%w1. RES_FORALL (PWORDLEN n2) (%w2. WSEG n1 n2 (WCAT (w1, w2)) = w1))"
+  by (import word_base WSEG_WCAT1)
+
+lemma WSEG_WCAT2: "RES_FORALL (PWORDLEN n1)
+ (%w1. RES_FORALL (PWORDLEN n2) (%w2. WSEG n2 0 (WCAT (w1, w2)) = w2))"
+  by (import word_base WSEG_WCAT2)
+
+lemma WSEG_SUC: "RES_FORALL (PWORDLEN n)
+ (%w. ALL k m1.
+         k + Suc m1 < n -->
+         WSEG (Suc m1) k w = WCAT (WSEG 1 (k + m1) w, WSEG m1 k w))"
+  by (import word_base WSEG_SUC)
+
+lemma WORD_CONS_WCAT: "WORD (x # l) = WCAT (WORD [x], WORD l)"
+  by (import word_base WORD_CONS_WCAT)
+
+lemma WORD_SNOC_WCAT: "WORD (SNOC x l) = WCAT (WORD l, WORD [x])"
+  by (import word_base WORD_SNOC_WCAT)
+
+lemma BIT_WCAT_FST: "RES_FORALL (PWORDLEN n1)
+ (%w1. RES_FORALL (PWORDLEN n2)
+        (%w2. ALL k.
+                 n2 <= k & k < n1 + n2 -->
+                 bit k (WCAT (w1, w2)) = bit (k - n2) w1))"
+  by (import word_base BIT_WCAT_FST)
+
+lemma BIT_WCAT_SND: "RES_FORALL (PWORDLEN n1)
+ (%w1. RES_FORALL (PWORDLEN n2)
+        (%w2. ALL k<n2. bit k (WCAT (w1, w2)) = bit k w2))"
+  by (import word_base BIT_WCAT_SND)
+
+lemma BIT_WCAT1: "RES_FORALL (PWORDLEN n) (%w. ALL b. bit n (WCAT (WORD [b], w)) = b)"
+  by (import word_base BIT_WCAT1)
+
+lemma WSEG_WCAT_WSEG1: "RES_FORALL (PWORDLEN n1)
+ (%w1. RES_FORALL (PWORDLEN n2)
+        (%w2. ALL m k.
+                 m <= n1 & n2 <= k -->
+                 WSEG m k (WCAT (w1, w2)) = WSEG m (k - n2) w1))"
+  by (import word_base WSEG_WCAT_WSEG1)
+
+lemma WSEG_WCAT_WSEG2: "RES_FORALL (PWORDLEN n1)
+ (%w1. RES_FORALL (PWORDLEN n2)
+        (%w2. ALL m k.
+                 m + k <= n2 --> WSEG m k (WCAT (w1, w2)) = WSEG m k w2))"
+  by (import word_base WSEG_WCAT_WSEG2)
+
+lemma WSEG_WCAT_WSEG: "RES_FORALL (PWORDLEN n1)
+ (%w1. RES_FORALL (PWORDLEN n2)
+        (%w2. ALL m k.
+                 m + k <= n1 + n2 & k < n2 & n2 <= m + k -->
+                 WSEG m k (WCAT (w1, w2)) =
+                 WCAT (WSEG (m + k - n2) 0 w1, WSEG (n2 - k) k w2)))"
+  by (import word_base WSEG_WCAT_WSEG)
+
+lemma BIT_EQ_IMP_WORD_EQ: "RES_FORALL (PWORDLEN n)
+ (%w1. RES_FORALL (PWORDLEN n)
+        (%w2. (ALL k<n. bit k w1 = bit k w2) --> w1 = w2))"
+  by (import word_base BIT_EQ_IMP_WORD_EQ)
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" word_num
+
+definition
+  LVAL :: "('a => nat) => nat => 'a list => nat"  where
+  "LVAL == %f b. foldl (%e x. b * e + f x) 0"
+
+lemma LVAL_DEF: "LVAL f b l = foldl (%e x. b * e + f x) 0 l"
+  by (import word_num LVAL_DEF)
+
+consts
+  NVAL :: "('a => nat) => nat => 'a word => nat" 
+
+specification (NVAL) NVAL_DEF: "ALL f b l. NVAL f b (WORD l) = LVAL f b l"
+  by (import word_num NVAL_DEF)
+
+lemma LVAL: "(ALL (x::'a => nat) xa::nat. LVAL x xa [] = (0::nat)) &
+(ALL (x::'a list) (xa::'a => nat) (xb::nat) xc::'a.
+    LVAL xa xb (xc # x) = xa xc * xb ^ length x + LVAL xa xb x)"
+  by (import word_num LVAL)
+
+lemma LVAL_SNOC: "LVAL f b (SNOC h l) = LVAL f b l * b + f h"
+  by (import word_num LVAL_SNOC)
+
+lemma LVAL_MAX: "(!!x. f x < b) ==> LVAL f b l < b ^ length l"
+  by (import word_num LVAL_MAX)
+
+lemma NVAL_MAX: "(!!x. f x < b) ==> RES_FORALL (PWORDLEN n) (%w. NVAL f b w < b ^ n)"
+  by (import word_num NVAL_MAX)
+
+lemma NVAL0: "NVAL x xa (WORD []) = 0"
+  by (import word_num NVAL0)
+
+lemma NVAL1: "NVAL x xa (WORD [xb]) = x xb"
+  by (import word_num NVAL1)
+
+lemma NVAL_WORDLEN_0: "RES_FORALL (PWORDLEN 0) (%w. ALL fv r. NVAL fv r w = 0)"
+  by (import word_num NVAL_WORDLEN_0)
+
+lemma NVAL_WCAT1: "NVAL f b (WCAT (w, WORD [x])) = NVAL f b w * b + f x"
+  by (import word_num NVAL_WCAT1)
+
+lemma NVAL_WCAT2: "RES_FORALL (PWORDLEN n)
+ (%w. ALL f b x. NVAL f b (WCAT (WORD [x], w)) = f x * b ^ n + NVAL f b w)"
+  by (import word_num NVAL_WCAT2)
+
+lemma NVAL_WCAT: "RES_FORALL (PWORDLEN n)
+ (%w1. RES_FORALL (PWORDLEN m)
+        (%w2. ALL f b.
+                 NVAL f b (WCAT (w1, w2)) =
+                 NVAL f b w1 * b ^ m + NVAL f b w2))"
+  by (import word_num NVAL_WCAT)
+
+consts
+  NLIST :: "nat => (nat => 'a) => nat => nat => 'a list" 
+
+specification (NLIST) NLIST_DEF: "(ALL (frep::nat => 'a) (b::nat) m::nat. NLIST (0::nat) frep b m = []) &
+(ALL (n::nat) (frep::nat => 'a) (b::nat) m::nat.
+    NLIST (Suc n) frep b m =
+    SNOC (frep (m mod b)) (NLIST n frep b (m div b)))"
+  by (import word_num NLIST_DEF)
+
+definition
+  NWORD :: "nat => (nat => 'a) => nat => nat => 'a word"  where
+  "NWORD == %n frep b m. WORD (NLIST n frep b m)"
+
+lemma NWORD_DEF: "NWORD n frep b m = WORD (NLIST n frep b m)"
+  by (import word_num NWORD_DEF)
+
+lemma NWORD_LENGTH: "WORDLEN (NWORD x xa xb xc) = x"
+  by (import word_num NWORD_LENGTH)
+
+lemma NWORD_PWORDLEN: "IN (NWORD x xa xb xc) (PWORDLEN x)"
+  by (import word_num NWORD_PWORDLEN)
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" word_bitop
+
+consts
+  PBITOP :: "('a word => 'b word) => bool" 
+
+defs
+  PBITOP_primdef: "PBITOP ==
+GSPEC
+ (%oper.
+     (oper,
+      ALL n.
+         RES_FORALL (PWORDLEN n)
+          (%w. IN (oper w) (PWORDLEN n) &
+               (ALL m k.
+                   m + k <= n --> oper (WSEG m k w) = WSEG m k (oper w)))))"
+
+lemma PBITOP_def: "PBITOP =
+GSPEC
+ (%oper.
+     (oper,
+      ALL n.
+         RES_FORALL (PWORDLEN n)
+          (%w. IN (oper w) (PWORDLEN n) &
+               (ALL m k.
+                   m + k <= n --> oper (WSEG m k w) = WSEG m k (oper w)))))"
+  by (import word_bitop PBITOP_def)
+
+lemma IN_PBITOP: "IN oper PBITOP =
+(ALL n.
+    RES_FORALL (PWORDLEN n)
+     (%w. IN (oper w) (PWORDLEN n) &
+          (ALL m k. m + k <= n --> oper (WSEG m k w) = WSEG m k (oper w))))"
+  by (import word_bitop IN_PBITOP)
+
+lemma PBITOP_PWORDLEN: "RES_FORALL PBITOP
+ (%oper. ALL n. RES_FORALL (PWORDLEN n) (%w. IN (oper w) (PWORDLEN n)))"
+  by (import word_bitop PBITOP_PWORDLEN)
+
+lemma PBITOP_WSEG: "RES_FORALL PBITOP
+ (%oper.
+     ALL n.
+        RES_FORALL (PWORDLEN n)
+         (%w. ALL m k.
+                 m + k <= n --> oper (WSEG m k w) = WSEG m k (oper w)))"
+  by (import word_bitop PBITOP_WSEG)
+
+lemma PBITOP_BIT: "RES_FORALL PBITOP
+ (%oper.
+     ALL n.
+        RES_FORALL (PWORDLEN n)
+         (%w. ALL k<n. oper (WORD [bit k w]) = WORD [bit k (oper w)]))"
+  by (import word_bitop PBITOP_BIT)
+
+consts
+  PBITBOP :: "('a word => 'b word => 'c word) => bool" 
+
+defs
+  PBITBOP_primdef: "PBITBOP ==
+GSPEC
+ (%oper.
+     (oper,
+      ALL n.
+         RES_FORALL (PWORDLEN n)
+          (%w1. RES_FORALL (PWORDLEN n)
+                 (%w2. IN (oper w1 w2) (PWORDLEN n) &
+                       (ALL m k.
+                           m + k <= n -->
+                           oper (WSEG m k w1) (WSEG m k w2) =
+                           WSEG m k (oper w1 w2))))))"
+
+lemma PBITBOP_def: "PBITBOP =
+GSPEC
+ (%oper.
+     (oper,
+      ALL n.
+         RES_FORALL (PWORDLEN n)
+          (%w1. RES_FORALL (PWORDLEN n)
+                 (%w2. IN (oper w1 w2) (PWORDLEN n) &
+                       (ALL m k.
+                           m + k <= n -->
+                           oper (WSEG m k w1) (WSEG m k w2) =
+                           WSEG m k (oper w1 w2))))))"
+  by (import word_bitop PBITBOP_def)
+
+lemma IN_PBITBOP: "IN oper PBITBOP =
+(ALL n.
+    RES_FORALL (PWORDLEN n)
+     (%w1. RES_FORALL (PWORDLEN n)
+            (%w2. IN (oper w1 w2) (PWORDLEN n) &
+                  (ALL m k.
+                      m + k <= n -->
+                      oper (WSEG m k w1) (WSEG m k w2) =
+                      WSEG m k (oper w1 w2)))))"
+  by (import word_bitop IN_PBITBOP)
+
+lemma PBITBOP_PWORDLEN: "RES_FORALL PBITBOP
+ (%oper.
+     ALL n.
+        RES_FORALL (PWORDLEN n)
+         (%w1. RES_FORALL (PWORDLEN n) (%w2. IN (oper w1 w2) (PWORDLEN n))))"
+  by (import word_bitop PBITBOP_PWORDLEN)
+
+lemma PBITBOP_WSEG: "RES_FORALL PBITBOP
+ (%oper.
+     ALL n.
+        RES_FORALL (PWORDLEN n)
+         (%w1. RES_FORALL (PWORDLEN n)
+                (%w2. ALL m k.
+                         m + k <= n -->
+                         oper (WSEG m k w1) (WSEG m k w2) =
+                         WSEG m k (oper w1 w2))))"
+  by (import word_bitop PBITBOP_WSEG)
+
+lemma PBITBOP_EXISTS: "EX x. ALL l1 l2. x (WORD l1) (WORD l2) = WORD (map2 f l1 l2)"
+  by (import word_bitop PBITBOP_EXISTS)
+
+consts
+  WMAP :: "('a => 'b) => 'a word => 'b word" 
+
+specification (WMAP) WMAP_DEF: "ALL f l. WMAP f (WORD l) = WORD (map f l)"
+  by (import word_bitop WMAP_DEF)
+
+lemma WMAP_PWORDLEN: "RES_FORALL (PWORDLEN n) (%w. ALL f. IN (WMAP f w) (PWORDLEN n))"
+  by (import word_bitop WMAP_PWORDLEN)
+
+lemma WMAP_0: "WMAP (x::'a => 'b) (WORD []) = WORD []"
+  by (import word_bitop WMAP_0)
+
+lemma WMAP_BIT: "RES_FORALL (PWORDLEN n) (%w. ALL k<n. ALL f. bit k (WMAP f w) = f (bit k w))"
+  by (import word_bitop WMAP_BIT)
+
+lemma WMAP_WSEG: "RES_FORALL (PWORDLEN n)
+ (%w. ALL m k.
+         m + k <= n --> (ALL f. WMAP f (WSEG m k w) = WSEG m k (WMAP f w)))"
+  by (import word_bitop WMAP_WSEG)
+
+lemma WMAP_PBITOP: "IN (WMAP f) PBITOP"
+  by (import word_bitop WMAP_PBITOP)
+
+lemma WMAP_WCAT: "WMAP (f::'a => 'b) (WCAT (w1::'a word, w2::'a word)) =
+WCAT (WMAP f w1, WMAP f w2)"
+  by (import word_bitop WMAP_WCAT)
+
+lemma WMAP_o: "WMAP (g::'b => 'c) (WMAP (f::'a => 'b) (w::'a word)) = WMAP (g o f) w"
+  by (import word_bitop WMAP_o)
+
+consts
+  FORALLBITS :: "('a => bool) => 'a word => bool" 
+
+specification (FORALLBITS) FORALLBITS_DEF: "ALL P l. FORALLBITS P (WORD l) = list_all P l"
+  by (import word_bitop FORALLBITS_DEF)
+
+lemma FORALLBITS: "RES_FORALL (PWORDLEN n) (%w. ALL P. FORALLBITS P w = (ALL k<n. P (bit k w)))"
+  by (import word_bitop FORALLBITS)
+
+lemma FORALLBITS_WSEG: "RES_FORALL (PWORDLEN n)
+ (%w. ALL P.
+         FORALLBITS P w -->
+         (ALL m k. m + k <= n --> FORALLBITS P (WSEG m k w)))"
+  by (import word_bitop FORALLBITS_WSEG)
+
+lemma FORALLBITS_WCAT: "FORALLBITS P (WCAT (w1, w2)) = (FORALLBITS P w1 & FORALLBITS P w2)"
+  by (import word_bitop FORALLBITS_WCAT)
+
+consts
+  EXISTSABIT :: "('a => bool) => 'a word => bool" 
+
+specification (EXISTSABIT) EXISTSABIT_DEF: "ALL P l. EXISTSABIT P (WORD l) = list_ex P l"
+  by (import word_bitop EXISTSABIT_DEF)
+
+lemma NOT_EXISTSABIT: "(~ EXISTSABIT P w) = FORALLBITS (Not o P) w"
+  by (import word_bitop NOT_EXISTSABIT)
+
+lemma NOT_FORALLBITS: "(~ FORALLBITS P w) = EXISTSABIT (Not o P) w"
+  by (import word_bitop NOT_FORALLBITS)
+
+lemma EXISTSABIT: "RES_FORALL (PWORDLEN n) (%w. ALL P. EXISTSABIT P w = (EX k<n. P (bit k w)))"
+  by (import word_bitop EXISTSABIT)
+
+lemma EXISTSABIT_WSEG: "RES_FORALL (PWORDLEN n)
+ (%w. ALL m k.
+         m + k <= n -->
+         (ALL P. EXISTSABIT P (WSEG m k w) --> EXISTSABIT P w))"
+  by (import word_bitop EXISTSABIT_WSEG)
+
+lemma EXISTSABIT_WCAT: "EXISTSABIT P (WCAT (w1, w2)) = (EXISTSABIT P w1 | EXISTSABIT P w2)"
+  by (import word_bitop EXISTSABIT_WCAT)
+
+definition
+  SHR :: "bool => 'a => 'a word => 'a word * 'a"  where
+  "SHR ==
+%f b w.
+   (WCAT
+     (if f then WSEG 1 (PRE (WORDLEN w)) w else WORD [b],
+      WSEG (PRE (WORDLEN w)) 1 w),
+    bit 0 w)"
+
+lemma SHR_DEF: "SHR f b w =
+(WCAT
+  (if f then WSEG 1 (PRE (WORDLEN w)) w else WORD [b],
+   WSEG (PRE (WORDLEN w)) 1 w),
+ bit 0 w)"
+  by (import word_bitop SHR_DEF)
+
+definition
+  SHL :: "bool => 'a word => 'a => 'a * 'a word"  where
+  "SHL ==
+%f w b.
+   (bit (PRE (WORDLEN w)) w,
+    WCAT (WSEG (PRE (WORDLEN w)) 0 w, if f then WSEG 1 0 w else WORD [b]))"
+
+lemma SHL_DEF: "SHL f w b =
+(bit (PRE (WORDLEN w)) w,
+ WCAT (WSEG (PRE (WORDLEN w)) 0 w, if f then WSEG 1 0 w else WORD [b]))"
+  by (import word_bitop SHL_DEF)
+
+lemma SHR_WSEG: "RES_FORALL (PWORDLEN n)
+ (%w. ALL m k.
+         m + k <= n -->
+         0 < m -->
+         (ALL f b.
+             SHR f b (WSEG m k w) =
+             (if f
+              then WCAT (WSEG 1 (k + (m - 1)) w, WSEG (m - 1) (k + 1) w)
+              else WCAT (WORD [b], WSEG (m - 1) (k + 1) w),
+              bit k w)))"
+  by (import word_bitop SHR_WSEG)
+
+lemma SHR_WSEG_1F: "RES_FORALL (PWORDLEN n)
+ (%w. ALL b m k.
+         m + k <= n -->
+         0 < m -->
+         SHR False b (WSEG m k w) =
+         (WCAT (WORD [b], WSEG (m - 1) (k + 1) w), bit k w))"
+  by (import word_bitop SHR_WSEG_1F)
+
+lemma SHR_WSEG_NF: "RES_FORALL (PWORDLEN n)
+ (%w. ALL m k.
+         m + k < n -->
+         0 < m -->
+         SHR False (bit (m + k) w) (WSEG m k w) =
+         (WSEG m (k + 1) w, bit k w))"
+  by (import word_bitop SHR_WSEG_NF)
+
+lemma SHL_WSEG: "RES_FORALL (PWORDLEN n)
+ (%w. ALL m k.
+         m + k <= n -->
+         0 < m -->
+         (ALL f b.
+             SHL f (WSEG m k w) b =
+             (bit (k + (m - 1)) w,
+              if f then WCAT (WSEG (m - 1) k w, WSEG 1 k w)
+              else WCAT (WSEG (m - 1) k w, WORD [b]))))"
+  by (import word_bitop SHL_WSEG)
+
+lemma SHL_WSEG_1F: "RES_FORALL (PWORDLEN n)
+ (%w. ALL b m k.
+         m + k <= n -->
+         0 < m -->
+         SHL False (WSEG m k w) b =
+         (bit (k + (m - 1)) w, WCAT (WSEG (m - 1) k w, WORD [b])))"
+  by (import word_bitop SHL_WSEG_1F)
+
+lemma SHL_WSEG_NF: "RES_FORALL (PWORDLEN n)
+ (%w. ALL m k.
+         m + k <= n -->
+         0 < m -->
+         0 < k -->
+         SHL False (WSEG m k w) (bit (k - 1) w) =
+         (bit (k + (m - 1)) w, WSEG m (k - 1) w))"
+  by (import word_bitop SHL_WSEG_NF)
+
+lemma WSEG_SHL: "RES_FORALL (PWORDLEN (Suc n))
+ (%w. ALL m k.
+         0 < k & m + k <= Suc n -->
+         (ALL b. WSEG m k (snd (SHL f w b)) = WSEG m (k - 1) w))"
+  by (import word_bitop WSEG_SHL)
+
+lemma WSEG_SHL_0: "RES_FORALL (PWORDLEN (Suc n))
+ (%w. ALL m b.
+         0 < m & m <= Suc n -->
+         WSEG m 0 (snd (SHL f w b)) =
+         WCAT (WSEG (m - 1) 0 w, if f then WSEG 1 0 w else WORD [b]))"
+  by (import word_bitop WSEG_SHL_0)
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" bword_num
+
+definition
+  BV :: "bool => nat"  where
+  "BV == %b. if b then Suc 0 else 0"
+
+lemma BV_DEF: "BV b = (if b then Suc 0 else 0)"
+  by (import bword_num BV_DEF)
+
+consts
+  BNVAL :: "bool word => nat" 
+
+specification (BNVAL) BNVAL_DEF: "ALL l. BNVAL (WORD l) = LVAL BV 2 l"
+  by (import bword_num BNVAL_DEF)
+
+lemma BV_LESS_2: "BV x < 2"
+  by (import bword_num BV_LESS_2)
+
+lemma BNVAL_NVAL: "BNVAL w = NVAL BV 2 w"
+  by (import bword_num BNVAL_NVAL)
+
+lemma BNVAL0: "BNVAL (WORD []) = 0"
+  by (import bword_num BNVAL0)
+
+lemma BNVAL_11: "[| WORDLEN w1 = WORDLEN w2; BNVAL w1 = BNVAL w2 |] ==> w1 = w2"
+  by (import bword_num BNVAL_11)
+
+lemma BNVAL_ONTO: "Ex (op = (BNVAL w))"
+  by (import bword_num BNVAL_ONTO)
+
+lemma BNVAL_MAX: "RES_FORALL (PWORDLEN n) (%w. BNVAL w < 2 ^ n)"
+  by (import bword_num BNVAL_MAX)
+
+lemma BNVAL_WCAT1: "RES_FORALL (PWORDLEN n)
+ (%w. ALL x. BNVAL (WCAT (w, WORD [x])) = BNVAL w * 2 + BV x)"
+  by (import bword_num BNVAL_WCAT1)
+
+lemma BNVAL_WCAT2: "RES_FORALL (PWORDLEN n)
+ (%w. ALL x. BNVAL (WCAT (WORD [x], w)) = BV x * 2 ^ n + BNVAL w)"
+  by (import bword_num BNVAL_WCAT2)
+
+lemma BNVAL_WCAT: "RES_FORALL (PWORDLEN n)
+ (%w1. RES_FORALL (PWORDLEN m)
+        (%w2. BNVAL (WCAT (w1, w2)) = BNVAL w1 * 2 ^ m + BNVAL w2))"
+  by (import bword_num BNVAL_WCAT)
+
+definition
+  VB :: "nat => bool"  where
+  "VB == %n. n mod 2 ~= 0"
+
+lemma VB_DEF: "VB n = (n mod 2 ~= 0)"
+  by (import bword_num VB_DEF)
+
+definition
+  NBWORD :: "nat => nat => bool word"  where
+  "NBWORD == %n m. WORD (NLIST n VB 2 m)"
+
+lemma NBWORD_DEF: "NBWORD n m = WORD (NLIST n VB 2 m)"
+  by (import bword_num NBWORD_DEF)
+
+lemma NBWORD0: "NBWORD 0 x = WORD []"
+  by (import bword_num NBWORD0)
+
+lemma WORDLEN_NBWORD: "WORDLEN (NBWORD x xa) = x"
+  by (import bword_num WORDLEN_NBWORD)
+
+lemma PWORDLEN_NBWORD: "IN (NBWORD x xa) (PWORDLEN x)"
+  by (import bword_num PWORDLEN_NBWORD)
+
+lemma NBWORD_SUC: "NBWORD (Suc n) m = WCAT (NBWORD n (m div 2), WORD [VB (m mod 2)])"
+  by (import bword_num NBWORD_SUC)
+
+lemma VB_BV: "VB (BV x) = x"
+  by (import bword_num VB_BV)
+
+lemma BV_VB: "x < 2 ==> BV (VB x) = x"
+  by (import bword_num BV_VB)
+
+lemma NBWORD_BNVAL: "RES_FORALL (PWORDLEN n) (%w. NBWORD n (BNVAL w) = w)"
+  by (import bword_num NBWORD_BNVAL)
+
+lemma BNVAL_NBWORD: "m < 2 ^ n ==> BNVAL (NBWORD n m) = m"
+  by (import bword_num BNVAL_NBWORD)
+
+lemma ZERO_WORD_VAL: "RES_FORALL (PWORDLEN n) (%w. (w = NBWORD n 0) = (BNVAL w = 0))"
+  by (import bword_num ZERO_WORD_VAL)
+
+lemma WCAT_NBWORD_0: "WCAT (NBWORD n1 0, NBWORD n2 0) = NBWORD (n1 + n2) 0"
+  by (import bword_num WCAT_NBWORD_0)
+
+lemma WSPLIT_NBWORD_0: "m <= n ==> WSPLIT m (NBWORD n 0) = (NBWORD (n - m) 0, NBWORD m 0)"
+  by (import bword_num WSPLIT_NBWORD_0)
+
+lemma EQ_NBWORD0_SPLIT: "RES_FORALL (PWORDLEN n)
+ (%w. ALL m<=n.
+         (w = NBWORD n 0) =
+         (WSEG (n - m) m w = NBWORD (n - m) 0 & WSEG m 0 w = NBWORD m 0))"
+  by (import bword_num EQ_NBWORD0_SPLIT)
+
+lemma NBWORD_MOD: "NBWORD n (m mod 2 ^ n) = NBWORD n m"
+  by (import bword_num NBWORD_MOD)
+
+lemma WSEG_NBWORD_SUC: "WSEG n 0 (NBWORD (Suc n) m) = NBWORD n m"
+  by (import bword_num WSEG_NBWORD_SUC)
+
+lemma NBWORD_SUC_WSEG: "RES_FORALL (PWORDLEN (Suc n)) (%w. NBWORD n (BNVAL w) = WSEG n 0 w)"
+  by (import bword_num NBWORD_SUC_WSEG)
+
+lemma DOUBL_EQ_SHL: "0 < x
+==> RES_FORALL (PWORDLEN x)
+     (%xa. ALL xb.
+              NBWORD x (BNVAL xa + BNVAL xa + BV xb) =
+              snd (SHL False xa xb))"
+  by (import bword_num DOUBL_EQ_SHL)
+
+lemma MSB_NBWORD: "bit n (NBWORD (Suc n) m) = VB (m div 2 ^ n mod 2)"
+  by (import bword_num MSB_NBWORD)
+
+lemma NBWORD_SPLIT: "NBWORD (n1 + n2) m = WCAT (NBWORD n1 (m div 2 ^ n2), NBWORD n2 m)"
+  by (import bword_num NBWORD_SPLIT)
+
+lemma WSEG_NBWORD: "m + k <= n ==> WSEG m k (NBWORD n l) = NBWORD m (l div 2 ^ k)"
+  by (import bword_num WSEG_NBWORD)
+
+lemma NBWORD_SUC_FST: "NBWORD (Suc n) x = WCAT (WORD [VB (x div 2 ^ n mod 2)], NBWORD n x)"
+  by (import bword_num NBWORD_SUC_FST)
+
+lemma BIT_NBWORD0: "k < n ==> bit k (NBWORD n 0) = False"
+  by (import bword_num BIT_NBWORD0)
+
+lemma ADD_BNVAL_LEFT: "RES_FORALL (PWORDLEN (Suc n))
+ (%w1. RES_FORALL (PWORDLEN (Suc n))
+        (%w2. BNVAL w1 + BNVAL w2 =
+              (BV (bit n w1) + BV (bit n w2)) * 2 ^ n +
+              (BNVAL (WSEG n 0 w1) + BNVAL (WSEG n 0 w2))))"
+  by (import bword_num ADD_BNVAL_LEFT)
+
+lemma ADD_BNVAL_RIGHT: "RES_FORALL (PWORDLEN (Suc n))
+ (%w1. RES_FORALL (PWORDLEN (Suc n))
+        (%w2. BNVAL w1 + BNVAL w2 =
+              (BNVAL (WSEG n 1 w1) + BNVAL (WSEG n 1 w2)) * 2 +
+              (BV (bit 0 w1) + BV (bit 0 w2))))"
+  by (import bword_num ADD_BNVAL_RIGHT)
+
+lemma ADD_BNVAL_SPLIT: "RES_FORALL (PWORDLEN (n1 + n2))
+ (%w1. RES_FORALL (PWORDLEN (n1 + n2))
+        (%w2. BNVAL w1 + BNVAL w2 =
+              (BNVAL (WSEG n1 n2 w1) + BNVAL (WSEG n1 n2 w2)) * 2 ^ n2 +
+              (BNVAL (WSEG n2 0 w1) + BNVAL (WSEG n2 0 w2))))"
+  by (import bword_num ADD_BNVAL_SPLIT)
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" bword_arith
+
+consts
+  ACARRY :: "nat => bool word => bool word => bool => bool" 
+
+specification (ACARRY) ACARRY_DEF: "(ALL w1 w2 cin. ACARRY 0 w1 w2 cin = cin) &
+(ALL n w1 w2 cin.
+    ACARRY (Suc n) w1 w2 cin =
+    VB ((BV (bit n w1) + BV (bit n w2) + BV (ACARRY n w1 w2 cin)) div 2))"
+  by (import bword_arith ACARRY_DEF)
+
+consts
+  ICARRY :: "nat => bool word => bool word => bool => bool" 
+
+specification (ICARRY) ICARRY_DEF: "(ALL w1 w2 cin. ICARRY 0 w1 w2 cin = cin) &
+(ALL n w1 w2 cin.
+    ICARRY (Suc n) w1 w2 cin =
+    (bit n w1 & bit n w2 | (bit n w1 | bit n w2) & ICARRY n w1 w2 cin))"
+  by (import bword_arith ICARRY_DEF)
+
+lemma ACARRY_EQ_ICARRY: "RES_FORALL (PWORDLEN n)
+ (%w1. RES_FORALL (PWORDLEN n)
+        (%w2. ALL cin k.
+                 k <= n --> ACARRY k w1 w2 cin = ICARRY k w1 w2 cin))"
+  by (import bword_arith ACARRY_EQ_ICARRY)
+
+lemma BNVAL_LESS_EQ: "RES_FORALL (PWORDLEN n) (%w. BNVAL w <= 2 ^ n - 1)"
+  by (import bword_arith BNVAL_LESS_EQ)
+
+lemma ADD_BNVAL_LESS_EQ1: "RES_FORALL (PWORDLEN n)
+ (%w1. RES_FORALL (PWORDLEN n)
+        (%w2. (BNVAL w1 + (BNVAL w2 + BV cin)) div 2 ^ n <= Suc 0))"
+  by (import bword_arith ADD_BNVAL_LESS_EQ1)
+
+lemma ADD_BV_BNVAL_DIV_LESS_EQ1: "RES_FORALL (PWORDLEN n)
+ (%w1. RES_FORALL (PWORDLEN n)
+        (%w2. (BV x1 + BV x2 +
+               (BNVAL w1 + (BNVAL w2 + BV cin)) div 2 ^ n) div
+              2
+              <= 1))"
+  by (import bword_arith ADD_BV_BNVAL_DIV_LESS_EQ1)
+
+lemma ADD_BV_BNVAL_LESS_EQ: "RES_FORALL (PWORDLEN n)
+ (%w1. RES_FORALL (PWORDLEN n)
+        (%w2. BV x1 + BV x2 + (BNVAL w1 + (BNVAL w2 + BV cin))
+              <= Suc (2 ^ Suc n)))"
+  by (import bword_arith ADD_BV_BNVAL_LESS_EQ)
+
+lemma ADD_BV_BNVAL_LESS_EQ1: "RES_FORALL (PWORDLEN n)
+ (%w1. RES_FORALL (PWORDLEN n)
+        (%w2. (BV x1 + BV x2 + (BNVAL w1 + (BNVAL w2 + BV cin))) div
+              2 ^ Suc n
+              <= 1))"
+  by (import bword_arith ADD_BV_BNVAL_LESS_EQ1)
+
+lemma ACARRY_EQ_ADD_DIV: "RES_FORALL (PWORDLEN n)
+ (%w1. RES_FORALL (PWORDLEN n)
+        (%w2. ALL k<n.
+                 BV (ACARRY k w1 w2 cin) =
+                 (BNVAL (WSEG k 0 w1) + BNVAL (WSEG k 0 w2) + BV cin) div
+                 2 ^ k))"
+  by (import bword_arith ACARRY_EQ_ADD_DIV)
+
+lemma ADD_WORD_SPLIT: "RES_FORALL (PWORDLEN (n1 + n2))
+ (%w1. RES_FORALL (PWORDLEN (n1 + n2))
+        (%w2. ALL cin.
+                 NBWORD (n1 + n2) (BNVAL w1 + BNVAL w2 + BV cin) =
+                 WCAT
+                  (NBWORD n1
+                    (BNVAL (WSEG n1 n2 w1) + BNVAL (WSEG n1 n2 w2) +
+                     BV (ACARRY n2 w1 w2 cin)),
+                   NBWORD n2
+                    (BNVAL (WSEG n2 0 w1) + BNVAL (WSEG n2 0 w2) +
+                     BV cin))))"
+  by (import bword_arith ADD_WORD_SPLIT)
+
+lemma WSEG_NBWORD_ADD: "RES_FORALL (PWORDLEN n)
+ (%w1. RES_FORALL (PWORDLEN n)
+        (%w2. ALL m k cin.
+                 m + k <= n -->
+                 WSEG m k (NBWORD n (BNVAL w1 + BNVAL w2 + BV cin)) =
+                 NBWORD m
+                  (BNVAL (WSEG m k w1) + BNVAL (WSEG m k w2) +
+                   BV (ACARRY k w1 w2 cin))))"
+  by (import bword_arith WSEG_NBWORD_ADD)
+
+lemma ADD_NBWORD_EQ0_SPLIT: "RES_FORALL (PWORDLEN (n1 + n2))
+ (%w1. RES_FORALL (PWORDLEN (n1 + n2))
+        (%w2. ALL cin.
+                 (NBWORD (n1 + n2) (BNVAL w1 + BNVAL w2 + BV cin) =
+                  NBWORD (n1 + n2) 0) =
+                 (NBWORD n1
+                   (BNVAL (WSEG n1 n2 w1) + BNVAL (WSEG n1 n2 w2) +
+                    BV (ACARRY n2 w1 w2 cin)) =
+                  NBWORD n1 0 &
+                  NBWORD n2
+                   (BNVAL (WSEG n2 0 w1) + BNVAL (WSEG n2 0 w2) + BV cin) =
+                  NBWORD n2 0)))"
+  by (import bword_arith ADD_NBWORD_EQ0_SPLIT)
+
+lemma ACARRY_MSB: "RES_FORALL (PWORDLEN n)
+ (%w1. RES_FORALL (PWORDLEN n)
+        (%w2. ALL cin.
+                 ACARRY n w1 w2 cin =
+                 bit n (NBWORD (Suc n) (BNVAL w1 + BNVAL w2 + BV cin))))"
+  by (import bword_arith ACARRY_MSB)
+
+lemma ACARRY_WSEG: "RES_FORALL (PWORDLEN n)
+ (%w1. RES_FORALL (PWORDLEN n)
+        (%w2. ALL cin k m.
+                 k < m & m <= n -->
+                 ACARRY k (WSEG m 0 w1) (WSEG m 0 w2) cin =
+                 ACARRY k w1 w2 cin))"
+  by (import bword_arith ACARRY_WSEG)
+
+lemma ICARRY_WSEG: "RES_FORALL (PWORDLEN n)
+ (%w1. RES_FORALL (PWORDLEN n)
+        (%w2. ALL cin k m.
+                 k < m & m <= n -->
+                 ICARRY k (WSEG m 0 w1) (WSEG m 0 w2) cin =
+                 ICARRY k w1 w2 cin))"
+  by (import bword_arith ICARRY_WSEG)
+
+lemma ACARRY_ACARRY_WSEG: "RES_FORALL (PWORDLEN n)
+ (%w1. RES_FORALL (PWORDLEN n)
+        (%w2. ALL cin m k1 k2.
+                 k1 < m & k2 < n & m + k2 <= n -->
+                 ACARRY k1 (WSEG m k2 w1) (WSEG m k2 w2)
+                  (ACARRY k2 w1 w2 cin) =
+                 ACARRY (k1 + k2) w1 w2 cin))"
+  by (import bword_arith ACARRY_ACARRY_WSEG)
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" bword_bitop
+
+consts
+  WNOT :: "bool word => bool word" 
+
+specification (WNOT) WNOT_DEF: "ALL l. WNOT (WORD l) = WORD (map Not l)"
+  by (import bword_bitop WNOT_DEF)
+
+lemma PBITOP_WNOT: "IN WNOT PBITOP"
+  by (import bword_bitop PBITOP_WNOT)
+
+lemma WNOT_WNOT: "WNOT (WNOT w) = w"
+  by (import bword_bitop WNOT_WNOT)
+
+lemma WCAT_WNOT: "RES_FORALL (PWORDLEN n1)
+ (%w1. RES_FORALL (PWORDLEN n2)
+        (%w2. WCAT (WNOT w1, WNOT w2) = WNOT (WCAT (w1, w2))))"
+  by (import bword_bitop WCAT_WNOT)
+
+consts
+  WAND :: "bool word => bool word => bool word" 
+
+specification (WAND) WAND_DEF: "ALL l1 l2. WAND (WORD l1) (WORD l2) = WORD (map2 op & l1 l2)"
+  by (import bword_bitop WAND_DEF)
+
+lemma PBITBOP_WAND: "IN WAND PBITBOP"
+  by (import bword_bitop PBITBOP_WAND)
+
+consts
+  WOR :: "bool word => bool word => bool word" 
+
+specification (WOR) WOR_DEF: "ALL l1 l2. WOR (WORD l1) (WORD l2) = WORD (map2 op | l1 l2)"
+  by (import bword_bitop WOR_DEF)
+
+lemma PBITBOP_WOR: "IN WOR PBITBOP"
+  by (import bword_bitop PBITBOP_WOR)
+
+consts
+  WXOR :: "bool word => bool word => bool word" 
+
+specification (WXOR) WXOR_DEF: "ALL l1 l2. WXOR (WORD l1) (WORD l2) = WORD (map2 op ~= l1 l2)"
+  by (import bword_bitop WXOR_DEF)
+
+lemma PBITBOP_WXOR: "IN WXOR PBITBOP"
+  by (import bword_bitop PBITBOP_WXOR)
+
+;end_setup
+
+end
+
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/HOL4Word32.thy
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/HOL4Word32.thy	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,1382 @@
+(* AUTOMATICALLY GENERATED, DO NOT EDIT! *)
+
+theory HOL4Word32 imports HOL4Base begin
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" bits
+
+consts
+  DIV2 :: "nat => nat" 
+
+defs
+  DIV2_primdef: "DIV2 == %n. n div 2"
+
+lemma DIV2_def: "DIV2 n = n div 2"
+  by (import bits DIV2_def)
+
+consts
+  TIMES_2EXP :: "nat => nat => nat" 
+
+defs
+  TIMES_2EXP_primdef: "TIMES_2EXP == %x n. n * 2 ^ x"
+
+lemma TIMES_2EXP_def: "TIMES_2EXP x n = n * 2 ^ x"
+  by (import bits TIMES_2EXP_def)
+
+consts
+  DIV_2EXP :: "nat => nat => nat" 
+
+defs
+  DIV_2EXP_primdef: "DIV_2EXP == %x n. n div 2 ^ x"
+
+lemma DIV_2EXP_def: "DIV_2EXP x n = n div 2 ^ x"
+  by (import bits DIV_2EXP_def)
+
+consts
+  MOD_2EXP :: "nat => nat => nat" 
+
+defs
+  MOD_2EXP_primdef: "MOD_2EXP == %x n. n mod 2 ^ x"
+
+lemma MOD_2EXP_def: "MOD_2EXP x n = n mod 2 ^ x"
+  by (import bits MOD_2EXP_def)
+
+consts
+  DIVMOD_2EXP :: "nat => nat => nat * nat" 
+
+defs
+  DIVMOD_2EXP_primdef: "DIVMOD_2EXP == %x n. (n div 2 ^ x, n mod 2 ^ x)"
+
+lemma DIVMOD_2EXP_def: "DIVMOD_2EXP x n = (n div 2 ^ x, n mod 2 ^ x)"
+  by (import bits DIVMOD_2EXP_def)
+
+consts
+  SBIT :: "bool => nat => nat" 
+
+defs
+  SBIT_primdef: "SBIT == %b n. if b then 2 ^ n else 0"
+
+lemma SBIT_def: "SBIT b n = (if b then 2 ^ n else 0)"
+  by (import bits SBIT_def)
+
+consts
+  BITS :: "nat => nat => nat => nat" 
+
+defs
+  BITS_primdef: "BITS == %h l n. MOD_2EXP (Suc h - l) (DIV_2EXP l n)"
+
+lemma BITS_def: "BITS h l n = MOD_2EXP (Suc h - l) (DIV_2EXP l n)"
+  by (import bits BITS_def)
+
+definition
+  bit :: "nat => nat => bool"  where
+  "bit == %b n. BITS b b n = 1"
+
+lemma BIT_def: "bit b n = (BITS b b n = 1)"
+  by (import bits BIT_def)
+
+consts
+  SLICE :: "nat => nat => nat => nat" 
+
+defs
+  SLICE_primdef: "SLICE == %h l n. MOD_2EXP (Suc h) n - MOD_2EXP l n"
+
+lemma SLICE_def: "SLICE h l n = MOD_2EXP (Suc h) n - MOD_2EXP l n"
+  by (import bits SLICE_def)
+
+consts
+  LSBn :: "nat => bool" 
+
+defs
+  LSBn_primdef: "LSBn == bit 0"
+
+lemma LSBn_def: "LSBn = bit 0"
+  by (import bits LSBn_def)
+
+consts
+  BITWISE :: "nat => (bool => bool => bool) => nat => nat => nat" 
+
+specification (BITWISE_primdef: BITWISE) BITWISE_def: "(ALL oper x y. BITWISE 0 oper x y = 0) &
+(ALL n oper x y.
+    BITWISE (Suc n) oper x y =
+    BITWISE n oper x y + SBIT (oper (bit n x) (bit n y)) n)"
+  by (import bits BITWISE_def)
+
+lemma SUC_SUB: "Suc a - a = 1"
+  by (import bits SUC_SUB)
+
+lemma DIV_MULT_1: "(r::nat) < (n::nat) ==> (n + r) div n = (1::nat)"
+  by (import bits DIV_MULT_1)
+
+lemma ZERO_LT_TWOEXP: "(0::nat) < (2::nat) ^ (n::nat)"
+  by (import bits ZERO_LT_TWOEXP)
+
+lemma MOD_2EXP_LT: "(k::nat) mod (2::nat) ^ (n::nat) < (2::nat) ^ n"
+  by (import bits MOD_2EXP_LT)
+
+lemma TWOEXP_DIVISION: "(k::nat) = k div (2::nat) ^ (n::nat) * (2::nat) ^ n + k mod (2::nat) ^ n"
+  by (import bits TWOEXP_DIVISION)
+
+lemma TWOEXP_MONO: "(a::nat) < (b::nat) ==> (2::nat) ^ a < (2::nat) ^ b"
+  by (import bits TWOEXP_MONO)
+
+lemma TWOEXP_MONO2: "(a::nat) <= (b::nat) ==> (2::nat) ^ a <= (2::nat) ^ b"
+  by (import bits TWOEXP_MONO2)
+
+lemma EXP_SUB_LESS_EQ: "(2::nat) ^ ((a::nat) - (b::nat)) <= (2::nat) ^ a"
+  by (import bits EXP_SUB_LESS_EQ)
+
+lemma BITS_THM: "BITS x xa xb = xb div 2 ^ xa mod 2 ^ (Suc x - xa)"
+  by (import bits BITS_THM)
+
+lemma BITSLT_THM: "BITS h l n < 2 ^ (Suc h - l)"
+  by (import bits BITSLT_THM)
+
+lemma DIV_MULT_LEM: "(0::nat) < (n::nat) ==> (m::nat) div n * n <= m"
+  by (import bits DIV_MULT_LEM)
+
+lemma MOD_2EXP_LEM: "(n::nat) mod (2::nat) ^ (x::nat) = n - n div (2::nat) ^ x * (2::nat) ^ x"
+  by (import bits MOD_2EXP_LEM)
+
+lemma BITS2_THM: "BITS h l n = n mod 2 ^ Suc h div 2 ^ l"
+  by (import bits BITS2_THM)
+
+lemma BITS_COMP_THM: "h2 + l1 <= h1 ==> BITS h2 l2 (BITS h1 l1 n) = BITS (h2 + l1) (l2 + l1) n"
+  by (import bits BITS_COMP_THM)
+
+lemma BITS_DIV_THM: "BITS h l x div 2 ^ n = BITS h (l + n) x"
+  by (import bits BITS_DIV_THM)
+
+lemma BITS_LT_HIGH: "n < 2 ^ Suc h ==> BITS h l n = n div 2 ^ l"
+  by (import bits BITS_LT_HIGH)
+
+lemma BITS_ZERO: "h < l ==> BITS h l n = 0"
+  by (import bits BITS_ZERO)
+
+lemma BITS_ZERO2: "BITS h l 0 = 0"
+  by (import bits BITS_ZERO2)
+
+lemma BITS_ZERO3: "BITS h 0 x = x mod 2 ^ Suc h"
+  by (import bits BITS_ZERO3)
+
+lemma BITS_COMP_THM2: "BITS h2 l2 (BITS h1 l1 n) = BITS (min h1 (h2 + l1)) (l2 + l1) n"
+  by (import bits BITS_COMP_THM2)
+
+lemma NOT_MOD2_LEM: "((n::nat) mod (2::nat) ~= (0::nat)) = (n mod (2::nat) = (1::nat))"
+  by (import bits NOT_MOD2_LEM)
+
+lemma NOT_MOD2_LEM2: "((n::nat) mod (2::nat) ~= (1::nat)) = (n mod (2::nat) = (0::nat))"
+  by (import bits NOT_MOD2_LEM2)
+
+lemma EVEN_MOD2_LEM: "EVEN n = (n mod 2 = 0)"
+  by (import bits EVEN_MOD2_LEM)
+
+lemma ODD_MOD2_LEM: "ODD n = (n mod 2 = 1)"
+  by (import bits ODD_MOD2_LEM)
+
+lemma LSB_ODD: "LSBn = ODD"
+  by (import bits LSB_ODD)
+
+lemma DIV_MULT_THM: "(n::nat) div (2::nat) ^ (x::nat) * (2::nat) ^ x = n - n mod (2::nat) ^ x"
+  by (import bits DIV_MULT_THM)
+
+lemma DIV_MULT_THM2: "(2::nat) * ((x::nat) div (2::nat)) = x - x mod (2::nat)"
+  by (import bits DIV_MULT_THM2)
+
+lemma LESS_EQ_EXP_MULT: "(a::nat) <= (b::nat) ==> EX x::nat. (2::nat) ^ b = x * (2::nat) ^ a"
+  by (import bits LESS_EQ_EXP_MULT)
+
+lemma SLICE_LEM1: "(a::nat) div (2::nat) ^ ((x::nat) + (y::nat)) * (2::nat) ^ (x + y) =
+a div (2::nat) ^ x * (2::nat) ^ x -
+a div (2::nat) ^ x mod (2::nat) ^ y * (2::nat) ^ x"
+  by (import bits SLICE_LEM1)
+
+lemma SLICE_LEM2: "(n::nat) mod (2::nat) ^ ((x::nat) + (y::nat)) =
+n mod (2::nat) ^ x + n div (2::nat) ^ x mod (2::nat) ^ y * (2::nat) ^ x"
+  by (import bits SLICE_LEM2)
+
+lemma SLICE_LEM3: "(l::nat) < (h::nat) ==> (n::nat) mod (2::nat) ^ Suc l <= n mod (2::nat) ^ h"
+  by (import bits SLICE_LEM3)
+
+lemma SLICE_THM: "SLICE h l n = BITS h l n * 2 ^ l"
+  by (import bits SLICE_THM)
+
+lemma SLICELT_THM: "SLICE h l n < 2 ^ Suc h"
+  by (import bits SLICELT_THM)
+
+lemma BITS_SLICE_THM: "BITS h l (SLICE h l n) = BITS h l n"
+  by (import bits BITS_SLICE_THM)
+
+lemma BITS_SLICE_THM2: "h <= h2 ==> BITS h2 l (SLICE h l n) = BITS h l n"
+  by (import bits BITS_SLICE_THM2)
+
+lemma MOD_2EXP_MONO: "(l::nat) <= (h::nat) ==> (n::nat) mod (2::nat) ^ l <= n mod (2::nat) ^ Suc h"
+  by (import bits MOD_2EXP_MONO)
+
+lemma SLICE_COMP_THM: "Suc m <= h & l <= m ==> SLICE h (Suc m) n + SLICE m l n = SLICE h l n"
+  by (import bits SLICE_COMP_THM)
+
+lemma SLICE_ZERO: "h < l ==> SLICE h l n = 0"
+  by (import bits SLICE_ZERO)
+
+lemma BIT_COMP_THM3: "Suc m <= h & l <= m
+==> BITS h (Suc m) n * 2 ^ (Suc m - l) + BITS m l n = BITS h l n"
+  by (import bits BIT_COMP_THM3)
+
+lemma NOT_BIT: "(~ bit n a) = (BITS n n a = 0)"
+  by (import bits NOT_BIT)
+
+lemma NOT_BITS: "(BITS n n a ~= 0) = (BITS n n a = 1)"
+  by (import bits NOT_BITS)
+
+lemma NOT_BITS2: "(BITS n n a ~= 1) = (BITS n n a = 0)"
+  by (import bits NOT_BITS2)
+
+lemma BIT_SLICE: "(bit n a = bit n b) = (SLICE n n a = SLICE n n b)"
+  by (import bits BIT_SLICE)
+
+lemma BIT_SLICE_LEM: "SBIT (bit x n) (x + y) = SLICE x x n * 2 ^ y"
+  by (import bits BIT_SLICE_LEM)
+
+lemma BIT_SLICE_THM: "SBIT (bit x xa) x = SLICE x x xa"
+  by (import bits BIT_SLICE_THM)
+
+lemma SBIT_DIV: "n < m ==> SBIT b (m - n) = SBIT b m div 2 ^ n"
+  by (import bits SBIT_DIV)
+
+lemma BITS_SUC: "l <= Suc h
+==> SBIT (bit (Suc h) n) (Suc h - l) + BITS h l n = BITS (Suc h) l n"
+  by (import bits BITS_SUC)
+
+lemma BITS_SUC_THM: "BITS (Suc h) l n =
+(if Suc h < l then 0 else SBIT (bit (Suc h) n) (Suc h - l) + BITS h l n)"
+  by (import bits BITS_SUC_THM)
+
+lemma BIT_BITS_THM: "(ALL x. l <= x & x <= h --> bit x a = bit x b) = (BITS h l a = BITS h l b)"
+  by (import bits BIT_BITS_THM)
+
+lemma BITWISE_LT_2EXP: "BITWISE n oper a b < 2 ^ n"
+  by (import bits BITWISE_LT_2EXP)
+
+lemma LESS_EXP_MULT2: "(a::nat) < (b::nat)
+==> EX x::nat. (2::nat) ^ b = (2::nat) ^ (x + (1::nat)) * (2::nat) ^ a"
+  by (import bits LESS_EXP_MULT2)
+
+lemma BITWISE_THM: "x < n ==> bit x (BITWISE n oper a b) = oper (bit x a) (bit x b)"
+  by (import bits BITWISE_THM)
+
+lemma BITWISE_COR: "[| x < n; oper (bit x a) (bit x b) |]
+==> BITWISE n oper a b div 2 ^ x mod 2 = 1"
+  by (import bits BITWISE_COR)
+
+lemma BITWISE_NOT_COR: "[| x < n; ~ oper (bit x a) (bit x b) |]
+==> BITWISE n oper a b div 2 ^ x mod 2 = 0"
+  by (import bits BITWISE_NOT_COR)
+
+lemma MOD_PLUS_RIGHT: "(0::nat) < (n::nat) ==> ((j::nat) + (k::nat) mod n) mod n = (j + k) mod n"
+  by (import bits MOD_PLUS_RIGHT)
+
+lemma MOD_PLUS_1: "(0::nat) < (n::nat)
+==> (((x::nat) + (1::nat)) mod n = (0::nat)) = (x mod n + (1::nat) = n)"
+  by (import bits MOD_PLUS_1)
+
+lemma MOD_ADD_1: "[| (0::nat) < (n::nat); ((x::nat) + (1::nat)) mod n ~= (0::nat) |]
+==> (x + (1::nat)) mod n = x mod n + (1::nat)"
+  by (import bits MOD_ADD_1)
+
+;end_setup
+
+setup_theory "~~/src/HOL/Import/HOL4/Generated" word32
+
+consts
+  HB :: "nat" 
+
+defs
+  HB_primdef: "HB ==
+NUMERAL
+ (NUMERAL_BIT1
+   (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO)))))"
+
+lemma HB_def: "HB =
+NUMERAL
+ (NUMERAL_BIT1
+   (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO)))))"
+  by (import word32 HB_def)
+
+consts
+  WL :: "nat" 
+
+defs
+  WL_primdef: "WL == Suc HB"
+
+lemma WL_def: "WL = Suc HB"
+  by (import word32 WL_def)
+
+consts
+  MODw :: "nat => nat" 
+
+defs
+  MODw_primdef: "MODw == %n. n mod 2 ^ WL"
+
+lemma MODw_def: "MODw n = n mod 2 ^ WL"
+  by (import word32 MODw_def)
+
+consts
+  INw :: "nat => bool" 
+
+defs
+  INw_primdef: "INw == %n. n < 2 ^ WL"
+
+lemma INw_def: "INw n = (n < 2 ^ WL)"
+  by (import word32 INw_def)
+
+consts
+  EQUIV :: "nat => nat => bool" 
+
+defs
+  EQUIV_primdef: "EQUIV == %x y. MODw x = MODw y"
+
+lemma EQUIV_def: "EQUIV x y = (MODw x = MODw y)"
+  by (import word32 EQUIV_def)
+
+lemma EQUIV_QT: "EQUIV x y = (EQUIV x = EQUIV y)"
+  by (import word32 EQUIV_QT)
+
+lemma FUNPOW_THM2: "(f ^^ Suc n) x = f ((f ^^ n) x)"
+  by (import word32 FUNPOW_THM2)
+
+lemma FUNPOW_COMP: "(f ^^ m) ((f ^^ n) a) = (f ^^ (m + n)) a"
+  by (import word32 FUNPOW_COMP)
+
+lemma INw_MODw: "INw (MODw n)"
+  by (import word32 INw_MODw)
+
+lemma TOw_IDEM: "INw a ==> MODw a = a"
+  by (import word32 TOw_IDEM)
+
+lemma MODw_IDEM2: "MODw (MODw a) = MODw a"
+  by (import word32 MODw_IDEM2)
+
+lemma TOw_QT: "EQUIV (MODw a) a"
+  by (import word32 TOw_QT)
+
+lemma MODw_THM: "MODw = BITS HB 0"
+  by (import word32 MODw_THM)
+
+lemma MOD_ADD: "MODw (a + b) = MODw (MODw a + MODw b)"
+  by (import word32 MOD_ADD)
+
+lemma MODw_MULT: "MODw (a * b) = MODw (MODw a * MODw b)"
+  by (import word32 MODw_MULT)
+
+consts
+  AONE :: "nat" 
+
+defs
+  AONE_primdef: "AONE == 1"
+
+lemma AONE_def: "AONE = 1"
+  by (import word32 AONE_def)
+
+lemma ADD_QT: "(ALL n. EQUIV (0 + n) n) & (ALL m n. EQUIV (Suc m + n) (Suc (m + n)))"
+  by (import word32 ADD_QT)
+
+lemma ADD_0_QT: "EQUIV (a + 0) a"
+  by (import word32 ADD_0_QT)
+
+lemma ADD_COMM_QT: "EQUIV (a + b) (b + a)"
+  by (import word32 ADD_COMM_QT)
+
+lemma ADD_ASSOC_QT: "EQUIV (a + (b + c)) (a + b + c)"
+  by (import word32 ADD_ASSOC_QT)
+
+lemma MULT_QT: "(ALL n. EQUIV (0 * n) 0) & (ALL m n. EQUIV (Suc m * n) (m * n + n))"
+  by (import word32 MULT_QT)
+
+lemma ADD1_QT: "EQUIV (Suc m) (m + AONE)"
+  by (import word32 ADD1_QT)
+
+lemma ADD_CLAUSES_QT: "(ALL m. EQUIV (0 + m) m) &
+(ALL m. EQUIV (m + 0) m) &
+(ALL m n. EQUIV (Suc m + n) (Suc (m + n))) &
+(ALL m n. EQUIV (m + Suc n) (Suc (m + n)))"
+  by (import word32 ADD_CLAUSES_QT)
+
+lemma SUC_EQUIV_COMP: "EQUIV (Suc a) b ==> EQUIV a (b + (2 ^ WL - 1))"
+  by (import word32 SUC_EQUIV_COMP)
+
+lemma INV_SUC_EQ_QT: "EQUIV (Suc m) (Suc n) = EQUIV m n"
+  by (import word32 INV_SUC_EQ_QT)
+
+lemma ADD_INV_0_QT: "EQUIV (m + n) m ==> EQUIV n 0"
+  by (import word32 ADD_INV_0_QT)
+
+lemma ADD_INV_0_EQ_QT: "EQUIV (m + n) m = EQUIV n 0"
+  by (import word32 ADD_INV_0_EQ_QT)
+
+lemma EQ_ADD_LCANCEL_QT: "EQUIV (m + n) (m + p) = EQUIV n p"
+  by (import word32 EQ_ADD_LCANCEL_QT)
+
+lemma EQ_ADD_RCANCEL_QT: "EQUIV (x + xb) (xa + xb) = EQUIV x xa"
+  by (import word32 EQ_ADD_RCANCEL_QT)
+
+lemma LEFT_ADD_DISTRIB_QT: "EQUIV (p * (m + n)) (p * m + p * n)"
+  by (import word32 LEFT_ADD_DISTRIB_QT)
+
+lemma MULT_ASSOC_QT: "EQUIV (m * (n * p)) (m * n * p)"
+  by (import word32 MULT_ASSOC_QT)
+
+lemma MULT_COMM_QT: "EQUIV (m * n) (n * m)"
+  by (import word32 MULT_COMM_QT)
+
+lemma MULT_CLAUSES_QT: "EQUIV (0 * m) 0 &
+EQUIV (m * 0) 0 &
+EQUIV (AONE * m) m &
+EQUIV (m * AONE) m &
+EQUIV (Suc m * n) (m * n + n) & EQUIV (m * Suc n) (m + m * n)"
+  by (import word32 MULT_CLAUSES_QT)
+
+consts
+  MSBn :: "nat => bool" 
+
+defs
+  MSBn_primdef: "MSBn == bit HB"
+
+lemma MSBn_def: "MSBn = bit HB"
+  by (import word32 MSBn_def)
+
+consts
+  ONE_COMP :: "nat => nat" 
+
+defs
+  ONE_COMP_primdef: "ONE_COMP == %x. 2 ^ WL - 1 - MODw x"
+
+lemma ONE_COMP_def: "ONE_COMP x = 2 ^ WL - 1 - MODw x"
+  by (import word32 ONE_COMP_def)
+
+consts
+  TWO_COMP :: "nat => nat" 
+
+defs
+  TWO_COMP_primdef: "TWO_COMP == %x. 2 ^ WL - MODw x"
+
+lemma TWO_COMP_def: "TWO_COMP x = 2 ^ WL - MODw x"
+  by (import word32 TWO_COMP_def)
+
+lemma ADD_TWO_COMP_QT: "EQUIV (MODw a + TWO_COMP a) 0"
+  by (import word32 ADD_TWO_COMP_QT)
+
+lemma TWO_COMP_ONE_COMP_QT: "EQUIV (TWO_COMP a) (ONE_COMP a + AONE)"
+  by (import word32 TWO_COMP_ONE_COMP_QT)
+
+lemma BIT_EQUIV_THM: "(ALL xb<WL. bit xb x = bit xb xa) = EQUIV x xa"
+  by (import word32 BIT_EQUIV_THM)
+
+lemma BITS_SUC2: "BITS (Suc n) 0 a = SLICE (Suc n) (Suc n) a + BITS n 0 a"
+  by (import word32 BITS_SUC2)
+
+lemma BITWISE_ONE_COMP_THM: "BITWISE WL (%x y. ~ x) a b = ONE_COMP a"
+  by (import word32 BITWISE_ONE_COMP_THM)
+
+lemma ONE_COMP_THM: "xa < WL ==> bit xa (ONE_COMP x) = (~ bit xa x)"
+  by (import word32 ONE_COMP_THM)
+
+consts
+  OR :: "nat => nat => nat" 
+
+defs
+  OR_primdef: "OR == BITWISE WL op |"
+
+lemma OR_def: "OR = BITWISE WL op |"
+  by (import word32 OR_def)
+
+consts
+  AND :: "nat => nat => nat" 
+
+defs
+  AND_primdef: "AND == BITWISE WL op &"
+
+lemma AND_def: "AND = BITWISE WL op &"
+  by (import word32 AND_def)
+
+consts
+  EOR :: "nat => nat => nat" 
+
+defs
+  EOR_primdef: "EOR == BITWISE WL op ~="
+
+lemma EOR_def: "EOR = BITWISE WL op ~="
+  by (import word32 EOR_def)
+
+consts
+  COMP0 :: "nat" 
+
+defs
+  COMP0_primdef: "COMP0 == ONE_COMP 0"
+
+lemma COMP0_def: "COMP0 = ONE_COMP 0"
+  by (import word32 COMP0_def)
+
+lemma BITWISE_THM2: "(ALL x<WL. oper (bit x a) (bit x b) = bit x y) =
+EQUIV (BITWISE WL oper a b) y"
+  by (import word32 BITWISE_THM2)
+
+lemma OR_ASSOC_QT: "EQUIV (OR a (OR b c)) (OR (OR a b) c)"
+  by (import word32 OR_ASSOC_QT)
+
+lemma OR_COMM_QT: "EQUIV (OR a b) (OR b a)"
+  by (import word32 OR_COMM_QT)
+
+lemma OR_ABSORB_QT: "EQUIV (AND a (OR a b)) a"
+  by (import word32 OR_ABSORB_QT)
+
+lemma OR_IDEM_QT: "EQUIV (OR a a) a"
+  by (import word32 OR_IDEM_QT)
+
+lemma AND_ASSOC_QT: "EQUIV (AND a (AND b c)) (AND (AND a b) c)"
+  by (import word32 AND_ASSOC_QT)
+
+lemma AND_COMM_QT: "EQUIV (AND a b) (AND b a)"
+  by (import word32 AND_COMM_QT)
+
+lemma AND_ABSORB_QT: "EQUIV (OR a (AND a b)) a"
+  by (import word32 AND_ABSORB_QT)
+
+lemma AND_IDEM_QT: "EQUIV (AND a a) a"
+  by (import word32 AND_IDEM_QT)
+
+lemma OR_COMP_QT: "EQUIV (OR a (ONE_COMP a)) COMP0"
+  by (import word32 OR_COMP_QT)
+
+lemma AND_COMP_QT: "EQUIV (AND a (ONE_COMP a)) 0"
+  by (import word32 AND_COMP_QT)
+
+lemma ONE_COMP_QT: "EQUIV (ONE_COMP (ONE_COMP a)) a"
+  by (import word32 ONE_COMP_QT)
+
+lemma RIGHT_AND_OVER_OR_QT: "EQUIV (AND (OR a b) c) (OR (AND a c) (AND b c))"
+  by (import word32 RIGHT_AND_OVER_OR_QT)
+
+lemma RIGHT_OR_OVER_AND_QT: "EQUIV (OR (AND a b) c) (AND (OR a c) (OR b c))"
+  by (import word32 RIGHT_OR_OVER_AND_QT)
+
+lemma DE_MORGAN_THM_QT: "EQUIV (ONE_COMP (AND a b)) (OR (ONE_COMP a) (ONE_COMP b)) &
+EQUIV (ONE_COMP (OR a b)) (AND (ONE_COMP a) (ONE_COMP b))"
+  by (import word32 DE_MORGAN_THM_QT)
+
+lemma BIT_EQUIV: "[| n < WL; EQUIV a b |] ==> bit n a = bit n b"
+  by (import word32 BIT_EQUIV)
+
+lemma LSB_WELLDEF: "EQUIV a b ==> LSBn a = LSBn b"
+  by (import word32 LSB_WELLDEF)
+
+lemma MSB_WELLDEF: "EQUIV a b ==> MSBn a = MSBn b"
+  by (import word32 MSB_WELLDEF)
+
+lemma BITWISE_ISTEP: "0 < n
+==> BITWISE n oper (a div 2) (b div 2) =
+    BITWISE n oper a b div 2 + SBIT (oper (bit n a) (bit n b)) (n - 1)"
+  by (import word32 BITWISE_ISTEP)
+
+lemma BITWISE_EVAL: "BITWISE (Suc n) oper a b =
+2 * BITWISE n oper (a div 2) (b div 2) + SBIT (oper (LSBn a) (LSBn b)) 0"
+  by (import word32 BITWISE_EVAL)
+
+lemma BITWISE_WELLDEF: "EQUIV a b & EQUIV c d ==> EQUIV (BITWISE n oper a c) (BITWISE n oper b d)"
+  by (import word32 BITWISE_WELLDEF)
+
+lemma BITWISEw_WELLDEF: "EQUIV a b & EQUIV c d ==> EQUIV (BITWISE WL oper a c) (BITWISE WL oper b d)"
+  by (import word32 BITWISEw_WELLDEF)
+
+lemma SUC_WELLDEF: "EQUIV a b ==> EQUIV (Suc a) (Suc b)"
+  by (import word32 SUC_WELLDEF)
+
+lemma ADD_WELLDEF: "EQUIV a b & EQUIV c d ==> EQUIV (a + c) (b + d)"
+  by (import word32 ADD_WELLDEF)
+
+lemma MUL_WELLDEF: "EQUIV a b & EQUIV c d ==> EQUIV (a * c) (b * d)"
+  by (import word32 MUL_WELLDEF)
+
+lemma ONE_COMP_WELLDEF: "EQUIV a b ==> EQUIV (ONE_COMP a) (ONE_COMP b)"
+  by (import word32 ONE_COMP_WELLDEF)
+
+lemma TWO_COMP_WELLDEF: "EQUIV a b ==> EQUIV (TWO_COMP a) (TWO_COMP b)"
+  by (import word32 TWO_COMP_WELLDEF)
+
+lemma TOw_WELLDEF: "EQUIV a b ==> EQUIV (MODw a) (MODw b)"
+  by (import word32 TOw_WELLDEF)
+
+consts
+  LSR_ONE :: "nat => nat" 
+
+defs
+  LSR_ONE_primdef: "LSR_ONE == %a. MODw a div 2"
+
+lemma LSR_ONE_def: "LSR_ONE a = MODw a div 2"
+  by (import word32 LSR_ONE_def)
+
+consts
+  ASR_ONE :: "nat => nat" 
+
+defs
+  ASR_ONE_primdef: "ASR_ONE == %a. LSR_ONE a + SBIT (MSBn a) HB"
+
+lemma ASR_ONE_def: "ASR_ONE a = LSR_ONE a + SBIT (MSBn a) HB"
+  by (import word32 ASR_ONE_def)
+
+consts
+  ROR_ONE :: "nat => nat" 
+
+defs
+  ROR_ONE_primdef: "ROR_ONE == %a. LSR_ONE a + SBIT (LSBn a) HB"
+
+lemma ROR_ONE_def: "ROR_ONE a = LSR_ONE a + SBIT (LSBn a) HB"
+  by (import word32 ROR_ONE_def)
+
+consts
+  RRXn :: "bool => nat => nat" 
+
+defs
+  RRXn_primdef: "RRXn == %c a. LSR_ONE a + SBIT c HB"
+
+lemma RRXn_def: "RRXn c a = LSR_ONE a + SBIT c HB"
+  by (import word32 RRXn_def)
+
+lemma LSR_ONE_WELLDEF: "EQUIV a b ==> EQUIV (LSR_ONE a) (LSR_ONE b)"
+  by (import word32 LSR_ONE_WELLDEF)
+
+lemma ASR_ONE_WELLDEF: "EQUIV a b ==> EQUIV (ASR_ONE a) (ASR_ONE b)"
+  by (import word32 ASR_ONE_WELLDEF)
+
+lemma ROR_ONE_WELLDEF: "EQUIV a b ==> EQUIV (ROR_ONE a) (ROR_ONE b)"
+  by (import word32 ROR_ONE_WELLDEF)
+
+lemma RRX_WELLDEF: "EQUIV a b ==> EQUIV (RRXn c a) (RRXn c b)"
+  by (import word32 RRX_WELLDEF)
+
+lemma LSR_ONE: "LSR_ONE = BITS HB 1"
+  by (import word32 LSR_ONE)
+
+typedef (open) word32 = "{x::nat => bool. EX xa. x = EQUIV xa}" 
+  by (rule typedef_helper,import word32 word32_TY_DEF)
+
+lemmas word32_TY_DEF = typedef_hol2hol4 [OF type_definition_word32]
+
+consts
+  mk_word32 :: "(nat => bool) => word32" 
+  dest_word32 :: "word32 => nat => bool" 
+
+specification (dest_word32 mk_word32) word32_tybij: "(ALL a. mk_word32 (dest_word32 a) = a) &
+(ALL r. (EX x. r = EQUIV x) = (dest_word32 (mk_word32 r) = r))"
+  by (import word32 word32_tybij)
+
+consts
+  w_0 :: "word32" 
+
+defs
+  w_0_primdef: "w_0 == mk_word32 (EQUIV 0)"
+
+lemma w_0_def: "w_0 = mk_word32 (EQUIV 0)"
+  by (import word32 w_0_def)
+
+consts
+  w_1 :: "word32" 
+
+defs
+  w_1_primdef: "w_1 == mk_word32 (EQUIV AONE)"
+
+lemma w_1_def: "w_1 = mk_word32 (EQUIV AONE)"
+  by (import word32 w_1_def)
+
+consts
+  w_T :: "word32" 
+
+defs
+  w_T_primdef: "w_T == mk_word32 (EQUIV COMP0)"
+
+lemma w_T_def: "w_T = mk_word32 (EQUIV COMP0)"
+  by (import word32 w_T_def)
+
+definition
+  word_suc :: "word32 => word32"  where
+  "word_suc == %T1. mk_word32 (EQUIV (Suc (Eps (dest_word32 T1))))"
+
+lemma word_suc: "word_suc T1 = mk_word32 (EQUIV (Suc (Eps (dest_word32 T1))))"
+  by (import word32 word_suc)
+
+definition
+  word_add :: "word32 => word32 => word32"  where
+  "word_add ==
+%T1 T2. mk_word32 (EQUIV (Eps (dest_word32 T1) + Eps (dest_word32 T2)))"
+
+lemma word_add: "word_add T1 T2 =
+mk_word32 (EQUIV (Eps (dest_word32 T1) + Eps (dest_word32 T2)))"
+  by (import word32 word_add)
+
+definition
+  word_mul :: "word32 => word32 => word32"  where
+  "word_mul ==
+%T1 T2. mk_word32 (EQUIV (Eps (dest_word32 T1) * Eps (dest_word32 T2)))"
+
+lemma word_mul: "word_mul T1 T2 =
+mk_word32 (EQUIV (Eps (dest_word32 T1) * Eps (dest_word32 T2)))"
+  by (import word32 word_mul)
+
+definition
+  word_1comp :: "word32 => word32"  where
+  "word_1comp == %T1. mk_word32 (EQUIV (ONE_COMP (Eps (dest_word32 T1))))"
+
+lemma word_1comp: "word_1comp T1 = mk_word32 (EQUIV (ONE_COMP (Eps (dest_word32 T1))))"
+  by (import word32 word_1comp)
+
+definition
+  word_2comp :: "word32 => word32"  where
+  "word_2comp == %T1. mk_word32 (EQUIV (TWO_COMP (Eps (dest_word32 T1))))"
+
+lemma word_2comp: "word_2comp T1 = mk_word32 (EQUIV (TWO_COMP (Eps (dest_word32 T1))))"
+  by (import word32 word_2comp)
+
+definition
+  word_lsr1 :: "word32 => word32"  where
+  "word_lsr1 == %T1. mk_word32 (EQUIV (LSR_ONE (Eps (dest_word32 T1))))"
+
+lemma word_lsr1: "word_lsr1 T1 = mk_word32 (EQUIV (LSR_ONE (Eps (dest_word32 T1))))"
+  by (import word32 word_lsr1)
+
+definition
+  word_asr1 :: "word32 => word32"  where
+  "word_asr1 == %T1. mk_word32 (EQUIV (ASR_ONE (Eps (dest_word32 T1))))"
+
+lemma word_asr1: "word_asr1 T1 = mk_word32 (EQUIV (ASR_ONE (Eps (dest_word32 T1))))"
+  by (import word32 word_asr1)
+
+definition
+  word_ror1 :: "word32 => word32"  where
+  "word_ror1 == %T1. mk_word32 (EQUIV (ROR_ONE (Eps (dest_word32 T1))))"
+
+lemma word_ror1: "word_ror1 T1 = mk_word32 (EQUIV (ROR_ONE (Eps (dest_word32 T1))))"
+  by (import word32 word_ror1)
+
+consts
+  RRX :: "bool => word32 => word32" 
+
+defs
+  RRX_primdef: "RRX == %T1 T2. mk_word32 (EQUIV (RRXn T1 (Eps (dest_word32 T2))))"
+
+lemma RRX_def: "RRX T1 T2 = mk_word32 (EQUIV (RRXn T1 (Eps (dest_word32 T2))))"
+  by (import word32 RRX_def)
+
+consts
+  LSB :: "word32 => bool" 
+
+defs
+  LSB_primdef: "LSB == %T1. LSBn (Eps (dest_word32 T1))"
+
+lemma LSB_def: "LSB T1 = LSBn (Eps (dest_word32 T1))"
+  by (import word32 LSB_def)
+
+consts
+  MSB :: "word32 => bool" 
+
+defs
+  MSB_primdef: "MSB == %T1. MSBn (Eps (dest_word32 T1))"
+
+lemma MSB_def: "MSB T1 = MSBn (Eps (dest_word32 T1))"
+  by (import word32 MSB_def)
+
+definition
+  bitwise_or :: "word32 => word32 => word32"  where
+  "bitwise_or ==
+%T1 T2. mk_word32 (EQUIV (OR (Eps (dest_word32 T1)) (Eps (dest_word32 T2))))"
+
+lemma bitwise_or: "bitwise_or T1 T2 =
+mk_word32 (EQUIV (OR (Eps (dest_word32 T1)) (Eps (dest_word32 T2))))"
+  by (import word32 bitwise_or)
+
+definition
+  bitwise_eor :: "word32 => word32 => word32"  where
+  "bitwise_eor ==
+%T1 T2.
+   mk_word32 (EQUIV (EOR (Eps (dest_word32 T1)) (Eps (dest_word32 T2))))"
+
+lemma bitwise_eor: "bitwise_eor T1 T2 =
+mk_word32 (EQUIV (EOR (Eps (dest_word32 T1)) (Eps (dest_word32 T2))))"
+  by (import word32 bitwise_eor)
+
+definition
+  bitwise_and :: "word32 => word32 => word32"  where
+  "bitwise_and ==
+%T1 T2.
+   mk_word32 (EQUIV (AND (Eps (dest_word32 T1)) (Eps (dest_word32 T2))))"
+
+lemma bitwise_and: "bitwise_and T1 T2 =
+mk_word32 (EQUIV (AND (Eps (dest_word32 T1)) (Eps (dest_word32 T2))))"
+  by (import word32 bitwise_and)
+
+consts
+  TOw :: "word32 => word32" 
+
+defs
+  TOw_primdef: "TOw == %T1. mk_word32 (EQUIV (MODw (Eps (dest_word32 T1))))"
+
+lemma TOw_def: "TOw T1 = mk_word32 (EQUIV (MODw (Eps (dest_word32 T1))))"
+  by (import word32 TOw_def)
+
+consts
+  n2w :: "nat => word32" 
+
+defs
+  n2w_primdef: "n2w == %n. mk_word32 (EQUIV n)"
+
+lemma n2w_def: "n2w n = mk_word32 (EQUIV n)"
+  by (import word32 n2w_def)
+
+consts
+  w2n :: "word32 => nat" 
+
+defs
+  w2n_primdef: "w2n == %w. MODw (Eps (dest_word32 w))"
+
+lemma w2n_def: "w2n w = MODw (Eps (dest_word32 w))"
+  by (import word32 w2n_def)
+
+lemma ADDw: "(ALL x. word_add w_0 x = x) &
+(ALL x xa. word_add (word_suc x) xa = word_suc (word_add x xa))"
+  by (import word32 ADDw)
+
+lemma ADD_0w: "word_add x w_0 = x"
+  by (import word32 ADD_0w)
+
+lemma ADD1w: "word_suc x = word_add x w_1"
+  by (import word32 ADD1w)
+
+lemma ADD_ASSOCw: "word_add x (word_add xa xb) = word_add (word_add x xa) xb"
+  by (import word32 ADD_ASSOCw)
+
+lemma ADD_CLAUSESw: "(ALL x. word_add w_0 x = x) &
+(ALL x. word_add x w_0 = x) &
+(ALL x xa. word_add (word_suc x) xa = word_suc (word_add x xa)) &
+(ALL x xa. word_add x (word_suc xa) = word_suc (word_add x xa))"
+  by (import word32 ADD_CLAUSESw)
+
+lemma ADD_COMMw: "word_add x xa = word_add xa x"
+  by (import word32 ADD_COMMw)
+
+lemma ADD_INV_0_EQw: "(word_add x xa = x) = (xa = w_0)"
+  by (import word32 ADD_INV_0_EQw)
+
+lemma EQ_ADD_LCANCELw: "(word_add x xa = word_add x xb) = (xa = xb)"
+  by (import word32 EQ_ADD_LCANCELw)
+
+lemma EQ_ADD_RCANCELw: "(word_add x xb = word_add xa xb) = (x = xa)"
+  by (import word32 EQ_ADD_RCANCELw)
+
+lemma LEFT_ADD_DISTRIBw: "word_mul xb (word_add x xa) = word_add (word_mul xb x) (word_mul xb xa)"
+  by (import word32 LEFT_ADD_DISTRIBw)
+
+lemma MULT_ASSOCw: "word_mul x (word_mul xa xb) = word_mul (word_mul x xa) xb"
+  by (import word32 MULT_ASSOCw)
+
+lemma MULT_COMMw: "word_mul x xa = word_mul xa x"
+  by (import word32 MULT_COMMw)
+
+lemma MULT_CLAUSESw: "word_mul w_0 x = w_0 &
+word_mul x w_0 = w_0 &
+word_mul w_1 x = x &
+word_mul x w_1 = x &
+word_mul (word_suc x) xa = word_add (word_mul x xa) xa &
+word_mul x (word_suc xa) = word_add x (word_mul x xa)"
+  by (import word32 MULT_CLAUSESw)
+
+lemma TWO_COMP_ONE_COMP: "word_2comp x = word_add (word_1comp x) w_1"
+  by (import word32 TWO_COMP_ONE_COMP)
+
+lemma OR_ASSOCw: "bitwise_or x (bitwise_or xa xb) = bitwise_or (bitwise_or x xa) xb"
+  by (import word32 OR_ASSOCw)
+
+lemma OR_COMMw: "bitwise_or x xa = bitwise_or xa x"
+  by (import word32 OR_COMMw)
+
+lemma OR_IDEMw: "bitwise_or x x = x"
+  by (import word32 OR_IDEMw)
+
+lemma OR_ABSORBw: "bitwise_and x (bitwise_or x xa) = x"
+  by (import word32 OR_ABSORBw)
+
+lemma AND_ASSOCw: "bitwise_and x (bitwise_and xa xb) = bitwise_and (bitwise_and x xa) xb"
+  by (import word32 AND_ASSOCw)
+
+lemma AND_COMMw: "bitwise_and x xa = bitwise_and xa x"
+  by (import word32 AND_COMMw)
+
+lemma AND_IDEMw: "bitwise_and x x = x"
+  by (import word32 AND_IDEMw)
+
+lemma AND_ABSORBw: "bitwise_or x (bitwise_and x xa) = x"
+  by (import word32 AND_ABSORBw)
+
+lemma ONE_COMPw: "word_1comp (word_1comp x) = x"
+  by (import word32 ONE_COMPw)
+
+lemma RIGHT_AND_OVER_ORw: "bitwise_and (bitwise_or x xa) xb =
+bitwise_or (bitwise_and x xb) (bitwise_and xa xb)"
+  by (import word32 RIGHT_AND_OVER_ORw)
+
+lemma RIGHT_OR_OVER_ANDw: "bitwise_or (bitwise_and x xa) xb =
+bitwise_and (bitwise_or x xb) (bitwise_or xa xb)"
+  by (import word32 RIGHT_OR_OVER_ANDw)
+
+lemma DE_MORGAN_THMw: "word_1comp (bitwise_and x xa) = bitwise_or (word_1comp x) (word_1comp xa) &
+word_1comp (bitwise_or x xa) = bitwise_and (word_1comp x) (word_1comp xa)"
+  by (import word32 DE_MORGAN_THMw)
+
+lemma w_0: "w_0 = n2w 0"
+  by (import word32 w_0)
+
+lemma w_1: "w_1 = n2w 1"
+  by (import word32 w_1)
+
+lemma w_T: "w_T =
+n2w (NUMERAL
+      (NUMERAL_BIT1
+        (NUMERAL_BIT1
+          (NUMERAL_BIT1
+            (NUMERAL_BIT1
+              (NUMERAL_BIT1
+                (NUMERAL_BIT1
+                  (NUMERAL_BIT1
+                    (NUMERAL_BIT1
+                      (NUMERAL_BIT1
+                        (NUMERAL_BIT1
+                          (NUMERAL_BIT1
+                            (NUMERAL_BIT1
+                              (NUMERAL_BIT1
+                                (NUMERAL_BIT1
+                                  (NUMERAL_BIT1
+                                    (NUMERAL_BIT1
+(NUMERAL_BIT1
+  (NUMERAL_BIT1
+    (NUMERAL_BIT1
+      (NUMERAL_BIT1
+        (NUMERAL_BIT1
+          (NUMERAL_BIT1
+            (NUMERAL_BIT1
+              (NUMERAL_BIT1
+                (NUMERAL_BIT1
+                  (NUMERAL_BIT1
+                    (NUMERAL_BIT1
+                      (NUMERAL_BIT1
+                        (NUMERAL_BIT1
+                          (NUMERAL_BIT1
+                            (NUMERAL_BIT1
+                              (NUMERAL_BIT1
+                                ALT_ZERO)))))))))))))))))))))))))))))))))"
+  by (import word32 w_T)
+
+lemma ADD_TWO_COMP: "word_add x (word_2comp x) = w_0"
+  by (import word32 ADD_TWO_COMP)
+
+lemma ADD_TWO_COMP2: "word_add (word_2comp x) x = w_0"
+  by (import word32 ADD_TWO_COMP2)
+
+definition
+  word_sub :: "word32 => word32 => word32"  where
+  "word_sub == %a b. word_add a (word_2comp b)"
+
+lemma word_sub: "word_sub a b = word_add a (word_2comp b)"
+  by (import word32 word_sub)
+
+definition
+  word_lsl :: "word32 => nat => word32"  where
+  "word_lsl == %a n. word_mul a (n2w (2 ^ n))"
+
+lemma word_lsl: "word_lsl a n = word_mul a (n2w (2 ^ n))"
+  by (import word32 word_lsl)
+
+definition
+  word_lsr :: "word32 => nat => word32"  where
+  "word_lsr == %a n. (word_lsr1 ^^ n) a"
+
+lemma word_lsr: "word_lsr a n = (word_lsr1 ^^ n) a"
+  by (import word32 word_lsr)
+
+definition
+  word_asr :: "word32 => nat => word32"  where
+  "word_asr == %a n. (word_asr1 ^^ n) a"
+
+lemma word_asr: "word_asr a n = (word_asr1 ^^ n) a"
+  by (import word32 word_asr)
+
+definition
+  word_ror :: "word32 => nat => word32"  where
+  "word_ror == %a n. (word_ror1 ^^ n) a"
+
+lemma word_ror: "word_ror a n = (word_ror1 ^^ n) a"
+  by (import word32 word_ror)
+
+consts
+  BITw :: "nat => word32 => bool" 
+
+defs
+  BITw_primdef: "BITw == %b n. bit b (w2n n)"
+
+lemma BITw_def: "BITw b n = bit b (w2n n)"
+  by (import word32 BITw_def)
+
+consts
+  BITSw :: "nat => nat => word32 => nat" 
+
+defs
+  BITSw_primdef: "BITSw == %h l n. BITS h l (w2n n)"
+
+lemma BITSw_def: "BITSw h l n = BITS h l (w2n n)"
+  by (import word32 BITSw_def)
+
+consts
+  SLICEw :: "nat => nat => word32 => nat" 
+
+defs
+  SLICEw_primdef: "SLICEw == %h l n. SLICE h l (w2n n)"
+
+lemma SLICEw_def: "SLICEw h l n = SLICE h l (w2n n)"
+  by (import word32 SLICEw_def)
+
+lemma TWO_COMP_ADD: "word_2comp (word_add a b) = word_add (word_2comp a) (word_2comp b)"
+  by (import word32 TWO_COMP_ADD)
+
+lemma TWO_COMP_ELIM: "word_2comp (word_2comp a) = a"
+  by (import word32 TWO_COMP_ELIM)
+
+lemma ADD_SUB_ASSOC: "word_sub (word_add a b) c = word_add a (word_sub b c)"
+  by (import word32 ADD_SUB_ASSOC)
+
+lemma ADD_SUB_SYM: "word_sub (word_add a b) c = word_add (word_sub a c) b"
+  by (import word32 ADD_SUB_SYM)
+
+lemma SUB_EQUALw: "word_sub a a = w_0"
+  by (import word32 SUB_EQUALw)
+
+lemma ADD_SUBw: "word_sub (word_add a b) b = a"
+  by (import word32 ADD_SUBw)
+
+lemma SUB_SUBw: "word_sub a (word_sub b c) = word_sub (word_add a c) b"
+  by (import word32 SUB_SUBw)
+
+lemma ONE_COMP_TWO_COMP: "word_1comp a = word_sub (word_2comp a) w_1"
+  by (import word32 ONE_COMP_TWO_COMP)
+
+lemma SUBw: "word_sub (word_suc m) n = word_suc (word_sub m n)"
+  by (import word32 SUBw)
+
+lemma ADD_EQ_SUBw: "(word_add m n = p) = (m = word_sub p n)"
+  by (import word32 ADD_EQ_SUBw)
+
+lemma CANCEL_SUBw: "(word_sub n p = word_sub m p) = (n = m)"
+  by (import word32 CANCEL_SUBw)
+
+lemma SUB_PLUSw: "word_sub a (word_add b c) = word_sub (word_sub a b) c"
+  by (import word32 SUB_PLUSw)
+
+lemma word_nchotomy: "EX n. w = n2w n"
+  by (import word32 word_nchotomy)
+
+lemma dest_word_mk_word_eq3: "dest_word32 (mk_word32 (EQUIV a)) = EQUIV a"
+  by (import word32 dest_word_mk_word_eq3)
+
+lemma MODw_ELIM: "n2w (MODw n) = n2w n"
+  by (import word32 MODw_ELIM)
+
+lemma w2n_EVAL: "w2n (n2w n) = MODw n"
+  by (import word32 w2n_EVAL)
+
+lemma w2n_ELIM: "n2w (w2n a) = a"
+  by (import word32 w2n_ELIM)
+
+lemma n2w_11: "(n2w a = n2w b) = (MODw a = MODw b)"
+  by (import word32 n2w_11)
+
+lemma ADD_EVAL: "word_add (n2w a) (n2w b) = n2w (a + b)"
+  by (import word32 ADD_EVAL)
+
+lemma MUL_EVAL: "word_mul (n2w a) (n2w b) = n2w (a * b)"
+  by (import word32 MUL_EVAL)
+
+lemma ONE_COMP_EVAL: "word_1comp (n2w a) = n2w (ONE_COMP a)"
+  by (import word32 ONE_COMP_EVAL)
+
+lemma TWO_COMP_EVAL: "word_2comp (n2w a) = n2w (TWO_COMP a)"
+  by (import word32 TWO_COMP_EVAL)
+
+lemma LSR_ONE_EVAL: "word_lsr1 (n2w a) = n2w (LSR_ONE a)"
+  by (import word32 LSR_ONE_EVAL)
+
+lemma ASR_ONE_EVAL: "word_asr1 (n2w a) = n2w (ASR_ONE a)"
+  by (import word32 ASR_ONE_EVAL)
+
+lemma ROR_ONE_EVAL: "word_ror1 (n2w a) = n2w (ROR_ONE a)"
+  by (import word32 ROR_ONE_EVAL)
+
+lemma RRX_EVAL: "RRX c (n2w a) = n2w (RRXn c a)"
+  by (import word32 RRX_EVAL)
+
+lemma LSB_EVAL: "LSB (n2w a) = LSBn a"
+  by (import word32 LSB_EVAL)
+
+lemma MSB_EVAL: "MSB (n2w a) = MSBn a"
+  by (import word32 MSB_EVAL)
+
+lemma OR_EVAL: "bitwise_or (n2w a) (n2w b) = n2w (OR a b)"
+  by (import word32 OR_EVAL)
+
+lemma EOR_EVAL: "bitwise_eor (n2w a) (n2w b) = n2w (EOR a b)"
+  by (import word32 EOR_EVAL)
+
+lemma AND_EVAL: "bitwise_and (n2w a) (n2w b) = n2w (AND a b)"
+  by (import word32 AND_EVAL)
+
+lemma BITS_EVAL: "BITSw h l (n2w a) = BITS h l (MODw a)"
+  by (import word32 BITS_EVAL)
+
+lemma BIT_EVAL: "BITw b (n2w a) = bit b (MODw a)"
+  by (import word32 BIT_EVAL)
+
+lemma SLICE_EVAL: "SLICEw h l (n2w a) = SLICE h l (MODw a)"
+  by (import word32 SLICE_EVAL)
+
+lemma LSL_ADD: "word_lsl (word_lsl a m) n = word_lsl a (m + n)"
+  by (import word32 LSL_ADD)
+
+lemma LSR_ADD: "word_lsr (word_lsr x xa) xb = word_lsr x (xa + xb)"
+  by (import word32 LSR_ADD)
+
+lemma ASR_ADD: "word_asr (word_asr x xa) xb = word_asr x (xa + xb)"
+  by (import word32 ASR_ADD)
+
+lemma ROR_ADD: "word_ror (word_ror x xa) xb = word_ror x (xa + xb)"
+  by (import word32 ROR_ADD)
+
+lemma LSL_LIMIT: "HB < n ==> word_lsl w n = w_0"
+  by (import word32 LSL_LIMIT)
+
+lemma MOD_MOD_DIV: "INw (MODw a div 2 ^ b)"
+  by (import word32 MOD_MOD_DIV)
+
+lemma MOD_MOD_DIV_2EXP: "MODw (MODw a div 2 ^ n) div 2 = MODw a div 2 ^ Suc n"
+  by (import word32 MOD_MOD_DIV_2EXP)
+
+lemma LSR_EVAL: "word_lsr (n2w a) n = n2w (MODw a div 2 ^ n)"
+  by (import word32 LSR_EVAL)
+
+lemma LSR_THM: "word_lsr (n2w n) x = n2w (BITS HB (min WL x) n)"
+  by (import word32 LSR_THM)
+
+lemma LSR_LIMIT: "HB < x ==> word_lsr w x = w_0"
+  by (import word32 LSR_LIMIT)
+
+lemma LEFT_SHIFT_LESS: "(a::nat) < (2::nat) ^ (m::nat)
+==> (2::nat) ^ (n::nat) + a * (2::nat) ^ n <= (2::nat) ^ (m + n)"
+  by (import word32 LEFT_SHIFT_LESS)
+
+lemma ROR_THM: "word_ror (n2w n) x =
+(let x' = x mod WL
+ in n2w (BITS HB x' n + BITS (x' - 1) 0 n * 2 ^ (WL - x')))"
+  by (import word32 ROR_THM)
+
+lemma ROR_CYCLE: "word_ror w (x * WL) = w"
+  by (import word32 ROR_CYCLE)
+
+lemma ASR_THM: "word_asr (n2w n) x =
+(let x' = min HB x; s = BITS HB x' n
+ in n2w (if MSBn n then 2 ^ WL - 2 ^ (WL - x') + s else s))"
+  by (import word32 ASR_THM)
+
+lemma ASR_LIMIT: "HB <= x ==> word_asr w x = (if MSB w then w_T else w_0)"
+  by (import word32 ASR_LIMIT)
+
+lemma ZERO_SHIFT: "(ALL n. word_lsl w_0 n = w_0) &
+(ALL n. word_asr w_0 n = w_0) &
+(ALL n. word_lsr w_0 n = w_0) & (ALL n. word_ror w_0 n = w_0)"
+  by (import word32 ZERO_SHIFT)
+
+lemma ZERO_SHIFT2: "(ALL a. word_lsl a 0 = a) &
+(ALL a. word_asr a 0 = a) &
+(ALL a. word_lsr a 0 = a) & (ALL a. word_ror a 0 = a)"
+  by (import word32 ZERO_SHIFT2)
+
+lemma ASR_w_T: "word_asr w_T n = w_T"
+  by (import word32 ASR_w_T)
+
+lemma ROR_w_T: "word_ror w_T n = w_T"
+  by (import word32 ROR_w_T)
+
+lemma MODw_EVAL: "MODw x =
+x mod
+NUMERAL
+ (NUMERAL_BIT2
+   (NUMERAL_BIT1
+     (NUMERAL_BIT1
+       (NUMERAL_BIT1
+         (NUMERAL_BIT1
+           (NUMERAL_BIT1
+             (NUMERAL_BIT1
+               (NUMERAL_BIT1
+                 (NUMERAL_BIT1
+                   (NUMERAL_BIT1
+                     (NUMERAL_BIT1
+                       (NUMERAL_BIT1
+                         (NUMERAL_BIT1
+                           (NUMERAL_BIT1
+                             (NUMERAL_BIT1
+                               (NUMERAL_BIT1
+                                 (NUMERAL_BIT1
+                                   (NUMERAL_BIT1
+                                     (NUMERAL_BIT1
+ (NUMERAL_BIT1
+   (NUMERAL_BIT1
+     (NUMERAL_BIT1
+       (NUMERAL_BIT1
+         (NUMERAL_BIT1
+           (NUMERAL_BIT1
+             (NUMERAL_BIT1
+               (NUMERAL_BIT1
+                 (NUMERAL_BIT1
+                   (NUMERAL_BIT1
+                     (NUMERAL_BIT1
+                       (NUMERAL_BIT1
+                         (NUMERAL_BIT1
+                           ALT_ZERO))))))))))))))))))))))))))))))))"
+  by (import word32 MODw_EVAL)
+
+lemma ADD_EVAL2: "word_add (n2w a) (n2w b) = n2w (MODw (a + b))"
+  by (import word32 ADD_EVAL2)
+
+lemma MUL_EVAL2: "word_mul (n2w a) (n2w b) = n2w (MODw (a * b))"
+  by (import word32 MUL_EVAL2)
+
+lemma ONE_COMP_EVAL2: "word_1comp (n2w a) =
+n2w (2 ^
+     NUMERAL
+      (NUMERAL_BIT2
+        (NUMERAL_BIT1
+          (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO))))) -
+     1 -
+     MODw a)"
+  by (import word32 ONE_COMP_EVAL2)
+
+lemma TWO_COMP_EVAL2: "word_2comp (n2w a) =
+n2w (MODw
+      (2 ^
+       NUMERAL
+        (NUMERAL_BIT2
+          (NUMERAL_BIT1
+            (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO))))) -
+       MODw a))"
+  by (import word32 TWO_COMP_EVAL2)
+
+lemma LSR_ONE_EVAL2: "word_lsr1 (n2w a) = n2w (MODw a div 2)"
+  by (import word32 LSR_ONE_EVAL2)
+
+lemma ASR_ONE_EVAL2: "word_asr1 (n2w a) =
+n2w (MODw a div 2 +
+     SBIT (MSBn a)
+      (NUMERAL
+        (NUMERAL_BIT1
+          (NUMERAL_BIT1
+            (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO)))))))"
+  by (import word32 ASR_ONE_EVAL2)
+
+lemma ROR_ONE_EVAL2: "word_ror1 (n2w a) =
+n2w (MODw a div 2 +
+     SBIT (LSBn a)
+      (NUMERAL
+        (NUMERAL_BIT1
+          (NUMERAL_BIT1
+            (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO)))))))"
+  by (import word32 ROR_ONE_EVAL2)
+
+lemma RRX_EVAL2: "RRX c (n2w a) =
+n2w (MODw a div 2 +
+     SBIT c
+      (NUMERAL
+        (NUMERAL_BIT1
+          (NUMERAL_BIT1
+            (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO)))))))"
+  by (import word32 RRX_EVAL2)
+
+lemma LSB_EVAL2: "LSB (n2w a) = ODD a"
+  by (import word32 LSB_EVAL2)
+
+lemma MSB_EVAL2: "MSB (n2w a) =
+bit (NUMERAL
+      (NUMERAL_BIT1
+        (NUMERAL_BIT1
+          (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO))))))
+ a"
+  by (import word32 MSB_EVAL2)
+
+lemma OR_EVAL2: "bitwise_or (n2w a) (n2w b) =
+n2w (BITWISE
+      (NUMERAL
+        (NUMERAL_BIT2
+          (NUMERAL_BIT1
+            (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO))))))
+      op | a b)"
+  by (import word32 OR_EVAL2)
+
+lemma AND_EVAL2: "bitwise_and (n2w a) (n2w b) =
+n2w (BITWISE
+      (NUMERAL
+        (NUMERAL_BIT2
+          (NUMERAL_BIT1
+            (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO))))))
+      op & a b)"
+  by (import word32 AND_EVAL2)
+
+lemma EOR_EVAL2: "bitwise_eor (n2w a) (n2w b) =
+n2w (BITWISE
+      (NUMERAL
+        (NUMERAL_BIT2
+          (NUMERAL_BIT1
+            (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO))))))
+      op ~= a b)"
+  by (import word32 EOR_EVAL2)
+
+lemma BITWISE_EVAL2: "BITWISE n oper x y =
+(if n = 0 then 0
+ else 2 * BITWISE (n - 1) oper (x div 2) (y div 2) +
+      (if oper (ODD x) (ODD y) then 1 else 0))"
+  by (import word32 BITWISE_EVAL2)
+
+lemma BITSwLT_THM: "BITSw h l n < 2 ^ (Suc h - l)"
+  by (import word32 BITSwLT_THM)
+
+lemma BITSw_COMP_THM: "h2 + l1 <= h1 ==> BITS h2 l2 (BITSw h1 l1 n) = BITSw (h2 + l1) (l2 + l1) n"
+  by (import word32 BITSw_COMP_THM)
+
+lemma BITSw_DIV_THM: "BITSw h l x div 2 ^ n = BITSw h (l + n) x"
+  by (import word32 BITSw_DIV_THM)
+
+lemma BITw_THM: "BITw b n = (BITSw b b n = 1)"
+  by (import word32 BITw_THM)
+
+lemma SLICEw_THM: "SLICEw h l n = BITSw h l n * 2 ^ l"
+  by (import word32 SLICEw_THM)
+
+lemma BITS_SLICEw_THM: "BITS h l (SLICEw h l n) = BITSw h l n"
+  by (import word32 BITS_SLICEw_THM)
+
+lemma SLICEw_ZERO_THM: "SLICEw h 0 n = BITSw h 0 n"
+  by (import word32 SLICEw_ZERO_THM)
+
+lemma SLICEw_COMP_THM: "Suc m <= h & l <= m ==> SLICEw h (Suc m) a + SLICEw m l a = SLICEw h l a"
+  by (import word32 SLICEw_COMP_THM)
+
+lemma BITSw_ZERO: "h < l ==> BITSw h l n = 0"
+  by (import word32 BITSw_ZERO)
+
+lemma SLICEw_ZERO: "h < l ==> SLICEw h l n = 0"
+  by (import word32 SLICEw_ZERO)
+
+;end_setup
+
+end
+
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/arithmetic.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/arithmetic.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,271 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/bits.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/bits.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,115 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/bool.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/bool.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,198 @@
+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" > "HOL4Setup.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" > "HOL4Setup.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" > "HOL4Setup.TYPE_DEFINITION"
+  "TYPE_DEFINITION" > "HOL4Setup.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" > "HOL4Setup.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" > "HOL4Setup.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" > "HOL4Setup.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" > "HOL4Setup.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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/boolean_sequence.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/boolean_sequence.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,39 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/bword_arith.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/bword_arith.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,27 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/bword_bitop.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/bword_bitop.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,23 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/bword_num.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/bword_num.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,58 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/combin.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/combin.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,41 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/divides.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/divides.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,24 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/hrat.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/hrat.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,95 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/hreal.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/hreal.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,118 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/ind_type.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/ind_type.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,99 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/lim.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/lim.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,93 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/list.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/list.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,135 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/marker.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/marker.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,19 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/nets.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/nets.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,51 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/num.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/num.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,26 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/numeral.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/numeral.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,49 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/one.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/one.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,20 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/operator.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/operator.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,40 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/option.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/option.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,45 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/pair.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/pair.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,70 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/poly.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/poly.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,128 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/powser.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/powser.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,30 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/pred_set.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/pred_set.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,322 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/prim_rec.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/prim_rec.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,72 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/prime.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/prime.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,17 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/prob.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/prob.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,61 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/prob_algebra.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/prob_algebra.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,54 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/prob_canon.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/prob_canon.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,147 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/prob_extra.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/prob_extra.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,96 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/prob_indep.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/prob_indep.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,56 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/prob_pseudo.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/prob_pseudo.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,26 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/prob_uniform.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/prob_uniform.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,57 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/real.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/real.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,359 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/realax.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/realax.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,145 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/relation.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/relation.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,102 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/res_quan.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/res_quan.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,37 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/rich_list.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/rich_list.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,373 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/seq.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/seq.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,112 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/state_transformer.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/state_transformer.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,42 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/sum.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/sum.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,43 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/topology.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/topology.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,116 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/transc.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/transc.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,273 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/word32.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/word32.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,377 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/word_base.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/word_base.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,102 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/word_bitop.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/word_bitop.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,64 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Generated/word_num.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Generated/word_num.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,35 @@
+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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Template/GenHOL4Base.thy
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Template/GenHOL4Base.thy	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,284 @@
+(*  Title:      HOL/Import/Generate-HOL/GenHOL4Base.thy
+    Author:     Sebastian Skalberg, TU Muenchen
+*)
+
+theory GenHOL4Base
+imports "../../HOL4Syntax" "../Compatibility"
+begin
+
+import_segment "hol4"
+
+setup_dump "../Generated" "HOL4Base"
+
+append_dump {*theory HOL4Base
+imports "../../HOL4Syntax" "../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         > HOL4Setup.ONE_ONE
+  ONTO            > Fun.surj
+  TYPE_DEFINITION > HOL4Setup.TYPE_DEFINITION
+  LET             > Compatibility.LET;
+
+ignore_thms
+  BOUNDED_DEF
+  BOUNDED_THM
+  UNBOUNDED_DEF
+  UNBOUNDED_THM;
+
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" combin;
+
+const_maps
+  o > Fun.comp;
+
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" sum;
+
+type_maps
+  sum > Sum_Type.sum;
+
+const_maps
+  INL      > Sum_Type.Inl
+  INR      > Sum_Type.Inr
+  ISL      > Compatibility.ISL
+  ISR      > Compatibility.ISR
+  OUTL     > Compatibility.OUTL
+  OUTR     > Compatibility.OUTR
+  sum_case > Sum_Type.sum.sum_case;
+
+ignore_thms
+  sum_TY_DEF
+  sum_ISO_DEF
+  IS_SUM_REP
+  INL_DEF
+  INR_DEF
+  sum_Axiom;
+
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" one;
+
+type_maps
+  one > Product_Type.unit;
+
+const_maps
+  one > Product_Type.Unity;
+
+ignore_thms
+    one_TY_DEF
+    one_axiom
+    one_Axiom
+    one_DEF;
+
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" option;
+
+type_maps
+    option > Option.option;
+
+const_maps
+    NONE        > Option.option.None
+    SOME        > Option.option.Some
+    option_case > Option.option.option_case
+    OPTION_MAP  > Option.map
+    THE         > Option.the
+    IS_SOME     > Compatibility.IS_SOME
+    IS_NONE     > Compatibility.IS_NONE
+    OPTION_JOIN > Compatibility.OPTION_JOIN;
+
+ignore_thms
+    option_axiom
+    option_Axiom
+    option_TY_DEF
+    option_REP_ABS_DEF
+    SOME_DEF
+    NONE_DEF;
+
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" marker;
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" relation;
+
+const_renames
+  reflexive > pred_reflexive;
+
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" pair;
+
+type_maps
+    prod > Product_Type.prod;
+
+const_maps
+    ","       > Product_Type.Pair
+    FST       > Product_Type.fst
+    SND       > Product_Type.snd
+    CURRY     > Product_Type.curry
+    UNCURRY   > Product_Type.prod.prod_case
+    "##"      > Product_Type.map_pair
+    pair_case > Product_Type.prod.prod_case;
+
+ignore_thms
+    prod_TY_DEF
+    MK_PAIR_DEF
+    IS_PAIR_DEF
+    ABS_REP_prod
+    COMMA_DEF;
+
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" num;
+
+type_maps
+  num > Nat.nat;
+
+const_maps
+  SUC > Nat.Suc
+  0   > Groups.zero_class.zero :: nat;
+
+ignore_thms
+    num_TY_DEF
+    num_ISO_DEF
+    IS_NUM_REP
+    ZERO_REP_DEF
+    SUC_REP_DEF
+    ZERO_DEF
+    SUC_DEF;
+
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" prim_rec;
+
+const_maps
+    "<" > Orderings.ord_class.less :: "nat \<Rightarrow> nat \<Rightarrow> bool";
+
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" arithmetic;
+
+const_maps
+  ALT_ZERO     > Compatibility.ALT_ZERO
+  NUMERAL_BIT1 > Compatibility.NUMERAL_BIT1
+  NUMERAL_BIT2 > Compatibility.NUMERAL_BIT2
+  NUMERAL      > Compatibility.NUMERAL
+  num_case     > Nat.nat.nat_case
+  ">"          > Compatibility.nat_gt
+  ">="         > Compatibility.nat_ge
+  FUNPOW       > Compatibility.FUNPOW
+  "<="         > Orderings.ord_class.less_eq :: "nat \<Rightarrow> nat \<Rightarrow> bool"
+  "+"          > Groups.plus_class.plus :: "nat \<Rightarrow> nat \<Rightarrow> nat"
+  "*"          > Groups.times_class.times :: "nat \<Rightarrow> nat \<Rightarrow> nat"
+  "-"          > Groups.minus_class.minus :: "nat \<Rightarrow> nat \<Rightarrow> nat"
+  MIN          > Orderings.ord_class.min :: "nat \<Rightarrow> nat \<Rightarrow> nat"
+  MAX          > Orderings.ord_class.max :: "nat \<Rightarrow> nat \<Rightarrow> nat"
+  DIV          > Divides.div_class.div :: "nat \<Rightarrow> nat \<Rightarrow> nat"
+  MOD          > Divides.div_class.mod :: "nat \<Rightarrow> nat \<Rightarrow> nat"
+  EXP          > Power.power_class.power :: "nat \<Rightarrow> nat \<Rightarrow> nat";
+
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" hrat;
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" hreal;
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" numeral;
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" ind_type;
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" divides;
+
+const_maps
+  divides > Rings.dvd_class.dvd :: "nat \<Rightarrow> nat \<Rightarrow> bool";
+
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" prime;
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" list;
+
+type_maps
+    list > List.list;
+
+const_maps
+  CONS      > List.list.Cons
+  NIL       > List.list.Nil
+  list_case > List.list.list_case
+  NULL      > List.null
+  HD        > List.hd
+  TL        > List.tl
+  MAP       > List.map
+  MEM       > Compatibility.list_mem
+  FILTER    > List.filter
+  FOLDL     > List.foldl
+  EVERY     > List.list_all
+  REVERSE   > List.rev
+  LAST      > List.last
+  FRONT     > List.butlast
+  APPEND    > List.append
+  FLAT      > List.concat
+  LENGTH    > Nat.size_class.size
+  REPLICATE > List.replicate
+  list_size > Compatibility.list_size
+  SUM       > Compatibility.sum
+  FOLDR     > Compatibility.FOLDR
+  EXISTS    > List.list_ex
+  MAP2      > Compatibility.map2
+  ZIP       > Compatibility.ZIP
+  UNZIP     > Compatibility.unzip;
+
+ignore_thms
+  list_TY_DEF
+  list_repfns
+  list0_def
+  list1_def
+  NIL
+  CONS_def;
+
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" pred_set;
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" operator;
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" rich_list;
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" state_transformer;
+end_import;
+
+append_dump "end";
+
+flush_dump;
+
+import_segment "";
+
+end
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Template/GenHOL4Prob.thy
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Template/GenHOL4Prob.thy	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,52 @@
+(*  Title:      HOL/Import/Generate-HOL/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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Template/GenHOL4Real.thy
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Template/GenHOL4Real.thy	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,101 @@
+(*  Title:      HOL/Import/Generate-HOL/GenHOL4Real.thy
+    Author:     Sebastian Skalberg (TU Muenchen)
+*)
+
+theory GenHOL4Real
+imports GenHOL4Base
+begin
+
+import_segment "hol4"
+
+setup_dump "../Generated" "HOL4Real"
+
+append_dump {*theory HOL4Real
+imports HOL4Base
+begin
+*}
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" realax;
+
+type_maps
+  real > RealDef.real;
+
+const_maps
+  real_0   > Groups.zero_class.zero :: real
+  real_1   > Groups.one_class.one   :: real
+  real_neg > Groups.uminus_class.uminus :: "real \<Rightarrow> real"
+  inv > Fields.inverse_class.inverse :: "real \<Rightarrow> real"
+  real_add > Groups.plus_class.plus :: "real \<Rightarrow> real \<Rightarrow> real"
+  real_sub > Groups.minus_class.minus :: "real \<Rightarrow> real \<Rightarrow> real"
+  real_mul > Groups.times_class.times :: "real \<Rightarrow> real \<Rightarrow> real"
+  real_div > Fields.inverse_class.divide :: "real \<Rightarrow> real \<Rightarrow> real"
+  real_lt > Orderings.ord_class.less :: "real \<Rightarrow> real \<Rightarrow> bool"
+  mk_real > HOL.undefined   (* Otherwise proof_import_concl fails *)
+  dest_real > HOL.undefined
+
+ignore_thms
+    real_TY_DEF
+    real_tybij
+    real_0
+    real_1
+    real_neg
+    real_inv
+    real_add
+    real_mul
+    real_lt
+    real_of_hreal
+    hreal_of_real
+    REAL_ISO_EQ
+    REAL_POS
+    SUP_ALLPOS_LEMMA1
+    SUP_ALLPOS_LEMMA2
+    SUP_ALLPOS_LEMMA3
+    SUP_ALLPOS_LEMMA4;
+
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" real;
+
+const_maps
+  real_gt     > Compatibility.real_gt
+  real_ge     > Compatibility.real_ge
+  real_lte    > Orderings.ord_class.less_eq :: "real \<Rightarrow> real \<Rightarrow> bool"
+  real_sub    > Groups.minus_class.minus :: "real \<Rightarrow> real \<Rightarrow> real"
+  "/"         > Fields.inverse_class.divide :: "real \<Rightarrow> real \<Rightarrow> real"
+  pow         > Power.power_class.power :: "real \<Rightarrow> nat \<Rightarrow> real"
+  abs         > Groups.abs_class.abs :: "real => real"
+  real_of_num > RealDef.real :: "nat => real";
+
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" topology;
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" nets;
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" seq;
+const_renames
+"-->" > "hol4-->";
+
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" lim;
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" powser;
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" transc;
+end_import;
+
+import_theory "~~/src/HOL/Import/HOL4/Generated" poly;
+end_import;
+
+append_dump "end";
+
+flush_dump;
+
+import_segment "";
+
+end
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Template/GenHOL4Vec.thy
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Template/GenHOL4Vec.thy	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,49 @@
+(*  Title:      HOL/Import/Generate-HOL/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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL4/Template/GenHOL4Word32.thy
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL4/Template/GenHOL4Word32.thy	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,38 @@
+(*  Title:      HOL/Import/Generate-HOL/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 f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOLLight/HOLLight.thy
--- a/src/HOL/Import/HOLLight/HOLLight.thy	Sat Mar 03 21:51:38 2012 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,7470 +0,0 @@
-(* AUTOMATICALLY GENERATED, DO NOT EDIT! *)
-
-theory HOLLight imports "../HOLLightCompat" "../HOL4Syntax" begin 
-
-setup_theory "~~/src/HOL/Import/HOLLight" hollight
-
-consts
-  "_FALSITY_" :: "bool" ("'_FALSITY'_")
-
-defs
-  "_FALSITY__def": "_FALSITY_ == False"
-
-lemma DEF__FALSITY_: "_FALSITY_ = False"
-  by (import hollight DEF__FALSITY_)
-
-lemma CONJ_ACI: "(p & q) = (q & p) &
-((p & q) & r) = (p & q & r) &
-(p & q & r) = (q & p & r) & (p & p) = p & (p & p & q) = (p & q)"
-  by (import hollight CONJ_ACI)
-
-lemma DISJ_ACI: "(p | q) = (q | p) &
-((p | q) | r) = (p | q | r) &
-(p | q | r) = (q | p | r) & (p | p) = p & (p | p | q) = (p | q)"
-  by (import hollight DISJ_ACI)
-
-lemma IMP_CONJ_ALT: "(p & q --> r) = (q --> p --> r)"
-  by (import hollight IMP_CONJ_ALT)
-
-lemma EQ_CLAUSES: "(True = t) = t & (t = True) = t & (False = t) = (~ t) & (t = False) = (~ t)"
-  by (import hollight EQ_CLAUSES)
-
-lemma NOT_CLAUSES_WEAK: "(~ True) = False & (~ False) = True"
-  by (import hollight NOT_CLAUSES_WEAK)
-
-lemma AND_CLAUSES: "(True & t) = t &
-(t & True) = t & (False & t) = False & (t & False) = False & (t & t) = t"
-  by (import hollight AND_CLAUSES)
-
-lemma OR_CLAUSES: "(True | t) = True &
-(t | True) = True & (False | t) = t & (t | False) = t & (t | t) = t"
-  by (import hollight OR_CLAUSES)
-
-lemma IMP_CLAUSES: "(True --> t) = t &
-(t --> True) = True &
-(False --> t) = True & (t --> t) = True & (t --> False) = (~ t)"
-  by (import hollight IMP_CLAUSES)
-
-lemma IMP_EQ_CLAUSE: "((x::'q_851) = x --> (p::bool)) = p"
-  by (import hollight IMP_EQ_CLAUSE)
-
-lemma TRIV_EXISTS_AND_THM: "(EX x::'A. (P::bool) & (Q::bool)) = ((EX x::'A. P) & (EX x::'A. Q))"
-  by (import hollight TRIV_EXISTS_AND_THM)
-
-lemma TRIV_AND_EXISTS_THM: "((EX x::'A. (P::bool)) & (EX x::'A. (Q::bool))) = (EX x::'A. P & Q)"
-  by (import hollight TRIV_AND_EXISTS_THM)
-
-lemma TRIV_FORALL_OR_THM: "(ALL x::'A. (P::bool) | (Q::bool)) = ((ALL x::'A. P) | (ALL x::'A. Q))"
-  by (import hollight TRIV_FORALL_OR_THM)
-
-lemma TRIV_OR_FORALL_THM: "((ALL x::'A. (P::bool)) | (ALL x::'A. (Q::bool))) = (ALL x::'A. P | Q)"
-  by (import hollight TRIV_OR_FORALL_THM)
-
-lemma TRIV_FORALL_IMP_THM: "(ALL x::'A. (P::bool) --> (Q::bool)) = ((EX x::'A. P) --> (ALL x::'A. Q))"
-  by (import hollight TRIV_FORALL_IMP_THM)
-
-lemma TRIV_EXISTS_IMP_THM: "(EX x::'A. (P::bool) --> (Q::bool)) = ((ALL x::'A. P) --> (EX x::'A. Q))"
-  by (import hollight TRIV_EXISTS_IMP_THM)
-
-lemma EXISTS_UNIQUE_ALT: "Ex1 (P::'A => bool) = (EX x::'A. ALL y::'A. P y = (x = y))"
-  by (import hollight EXISTS_UNIQUE_ALT)
-
-lemma SELECT_UNIQUE: "(!!y::'A. (P::'A => bool) y = (y = (x::'A))) ==> Eps P = x"
-  by (import hollight SELECT_UNIQUE)
-
-lemma EXCLUDED_MIDDLE: "t | ~ t"
-  by (import hollight EXCLUDED_MIDDLE)
-
-lemma COND_CLAUSES: "(if True then x::'A else (xa::'A)) = x & (if False then x else xa) = xa"
-  by (import hollight COND_CLAUSES)
-
-lemma COND_EXPAND: "(if b then t1 else t2) = ((~ b | t1) & (b | t2))"
-  by (import hollight COND_EXPAND)
-
-lemma COND_RATOR: "(if b::bool then f::'A => 'B else (g::'A => 'B)) (x::'A) =
-(if b then f x else g x)"
-  by (import hollight COND_RATOR)
-
-lemma COND_ABS: "(%x::'A. if b::bool then (f::'A => 'B) x else (g::'A => 'B) x) =
-(if b then f else g)"
-  by (import hollight COND_ABS)
-
-lemma MONO_COND: "[| (A --> B) & (C --> D); if b then A else C |] ==> if b then B else D"
-  by (import hollight MONO_COND)
-
-lemma SKOLEM_THM: "(ALL x::'A. Ex ((P::'A => 'B => bool) x)) =
-(EX x::'A => 'B. ALL xa::'A. P xa (x xa))"
-  by (import hollight SKOLEM_THM)
-
-lemma UNIQUE_SKOLEM_ALT: "(ALL x::'A. Ex1 ((P::'A => 'B => bool) x)) =
-(EX f::'A => 'B. ALL (x::'A) y::'B. P x y = (f x = y))"
-  by (import hollight UNIQUE_SKOLEM_ALT)
-
-lemma COND_EQ_CLAUSE: "(if (x::'q_2963) = x then y::'q_2956 else (z::'q_2956)) = y"
-  by (import hollight COND_EQ_CLAUSE)
-
-lemma bool_RECURSION: "EX x::bool => 'A. x False = (a::'A) & x True = (b::'A)"
-  by (import hollight bool_RECURSION)
-
-lemma o_ASSOC: "(f::'C => 'D) o ((g::'B => 'C) o (h::'A => 'B)) = f o g o h"
-  by (import hollight o_ASSOC)
-
-lemma I_O_ID: "id o (f::'A => 'B) = f & f o id = f"
-  by (import hollight I_O_ID)
-
-lemma EXISTS_ONE_REP: "EX x. x"
-  by (import hollight EXISTS_ONE_REP)
-
-lemma one_axiom: "(f::'A => unit) = (x::'A => unit)"
-  by (import hollight one_axiom)
-
-lemma one_RECURSION: "EX x::unit => 'A. x () = (e::'A)"
-  by (import hollight one_RECURSION)
-
-lemma one_Axiom: "EX! fn::unit => 'A. fn () = (e::'A)"
-  by (import hollight one_Axiom)
-
-lemma th_cond: "(b = False --> x = x0) & (b = True --> x = x1) ==> x = (b & x1 | ~ b & x0)"
-  by (import hollight th_cond)
-
-definition
-  LET_END :: "'A => 'A"  where
-  "LET_END == %t::'A. t"
-
-lemma DEF_LET_END: "LET_END = (%t::'A. t)"
-  by (import hollight DEF_LET_END)
-
-consts
-  "_SEQPATTERN" :: "('q_4007 => 'q_4004 => bool)
-=> ('q_4007 => 'q_4004 => bool) => 'q_4007 => 'q_4004 => bool" ("'_SEQPATTERN")
-
-defs
-  "_SEQPATTERN_def": "_SEQPATTERN ==
-%(r::'q_4007 => 'q_4004 => bool) (s::'q_4007 => 'q_4004 => bool) x::'q_4007.
-   if Ex (r x) then r x else s x"
-
-lemma DEF__SEQPATTERN: "_SEQPATTERN =
-(%(r::'q_4007 => 'q_4004 => bool) (s::'q_4007 => 'q_4004 => bool)
-    x::'q_4007. if Ex (r x) then r x else s x)"
-  by (import hollight DEF__SEQPATTERN)
-
-consts
-  "_UNGUARDED_PATTERN" :: "bool => bool => bool" ("'_UNGUARDED'_PATTERN")
-
-defs
-  "_UNGUARDED_PATTERN_def": "_UNGUARDED_PATTERN == op &"
-
-lemma DEF__UNGUARDED_PATTERN: "_UNGUARDED_PATTERN = op &"
-  by (import hollight DEF__UNGUARDED_PATTERN)
-
-consts
-  "_GUARDED_PATTERN" :: "bool => bool => bool => bool" ("'_GUARDED'_PATTERN")
-
-defs
-  "_GUARDED_PATTERN_def": "_GUARDED_PATTERN == %p g r. p & g & r"
-
-lemma DEF__GUARDED_PATTERN: "_GUARDED_PATTERN = (%p g r. p & g & r)"
-  by (import hollight DEF__GUARDED_PATTERN)
-
-consts
-  "_MATCH" :: "'q_4049 => ('q_4049 => 'q_4053 => bool) => 'q_4053" ("'_MATCH")
-
-defs
-  "_MATCH_def": "_MATCH ==
-%(e::'q_4049) r::'q_4049 => 'q_4053 => bool.
-   if Ex1 (r e) then Eps (r e) else SOME z::'q_4053. False"
-
-lemma DEF__MATCH: "_MATCH =
-(%(e::'q_4049) r::'q_4049 => 'q_4053 => bool.
-    if Ex1 (r e) then Eps (r e) else SOME z::'q_4053. False)"
-  by (import hollight DEF__MATCH)
-
-consts
-  "_FUNCTION" :: "('q_4071 => 'q_4075 => bool) => 'q_4071 => 'q_4075" ("'_FUNCTION")
-
-defs
-  "_FUNCTION_def": "_FUNCTION ==
-%(r::'q_4071 => 'q_4075 => bool) x::'q_4071.
-   if Ex1 (r x) then Eps (r x) else SOME z::'q_4075. False"
-
-lemma DEF__FUNCTION: "_FUNCTION =
-(%(r::'q_4071 => 'q_4075 => bool) x::'q_4071.
-    if Ex1 (r x) then Eps (r x) else SOME z::'q_4075. False)"
-  by (import hollight DEF__FUNCTION)
-
-lemma PAIR_EXISTS_THM: "EX (x::'A => 'B => bool) (a::'A) b::'B. x = Pair_Rep a b"
-  by (import hollight PAIR_EXISTS_THM)
-
-lemma pair_RECURSION: "EX x::'A * 'B => 'C.
-   ALL (a0::'A) a1::'B. x (a0, a1) = (PAIR'::'A => 'B => 'C) a0 a1"
-  by (import hollight pair_RECURSION)
-
-definition
-  UNCURRY :: "('A => 'B => 'C) => 'A * 'B => 'C"  where
-  "UNCURRY == %(u::'A => 'B => 'C) ua::'A * 'B. u (fst ua) (snd ua)"
-
-lemma DEF_UNCURRY: "UNCURRY = (%(u::'A => 'B => 'C) ua::'A * 'B. u (fst ua) (snd ua))"
-  by (import hollight DEF_UNCURRY)
-
-definition
-  PASSOC :: "(('A * 'B) * 'C => 'D) => 'A * 'B * 'C => 'D"  where
-  "PASSOC ==
-%(u::('A * 'B) * 'C => 'D) ua::'A * 'B * 'C.
-   u ((fst ua, fst (snd ua)), snd (snd ua))"
-
-lemma DEF_PASSOC: "PASSOC =
-(%(u::('A * 'B) * 'C => 'D) ua::'A * 'B * 'C.
-    u ((fst ua, fst (snd ua)), snd (snd ua)))"
-  by (import hollight DEF_PASSOC)
-
-lemma LAMBDA_PAIR_THM: "(x::'q_4547 * 'q_4546 => 'q_4539) =
-(SOME f::'q_4547 * 'q_4546 => 'q_4539.
-    ALL (xa::'q_4547) y::'q_4546. f (xa, y) = x (xa, y))"
-  by (import hollight LAMBDA_PAIR_THM)
-
-lemma FORALL_PAIRED_THM: "All (SOME f::'q_4576 * 'q_4575 => bool.
-        ALL (x::'q_4576) y::'q_4575.
-           f (x, y) = (P::'q_4576 => 'q_4575 => bool) x y) =
-(ALL x::'q_4576. All (P x))"
-  by (import hollight FORALL_PAIRED_THM)
-
-lemma EXISTS_PAIRED_THM: "Ex (SOME f::'q_4612 * 'q_4611 => bool.
-       ALL (x::'q_4612) y::'q_4611.
-          f (x, y) = (P::'q_4612 => 'q_4611 => bool) x y) =
-(EX x::'q_4612. Ex (P x))"
-  by (import hollight EXISTS_PAIRED_THM)
-
-lemma FORALL_TRIPLED_THM: "All (SOME f::'q_4649 * 'q_4648 * 'q_4647 => bool.
-        ALL (x::'q_4649) (y::'q_4648) z::'q_4647.
-           f (x, y, z) = (P::'q_4649 => 'q_4648 => 'q_4647 => bool) x y z) =
-(ALL (x::'q_4649) y::'q_4648. All (P x y))"
-  by (import hollight FORALL_TRIPLED_THM)
-
-lemma EXISTS_TRIPLED_THM: "Ex (SOME f::'q_4695 * 'q_4694 * 'q_4693 => bool.
-       ALL (x::'q_4695) (y::'q_4694) z::'q_4693.
-          f (x, y, z) = (P::'q_4695 => 'q_4694 => 'q_4693 => bool) x y z) =
-(EX (x::'q_4695) y::'q_4694. Ex (P x y))"
-  by (import hollight EXISTS_TRIPLED_THM)
-
-lemma IND_SUC_0_EXISTS: "EX (x::ind => ind) z::ind.
-   (ALL (x1::ind) x2::ind. (x x1 = x x2) = (x1 = x2)) &
-   (ALL xa::ind. x xa ~= z)"
-  by (import hollight IND_SUC_0_EXISTS)
-
-definition
-  IND_SUC :: "ind => ind"  where
-  "IND_SUC ==
-SOME f. EX z. (ALL x1 x2. (f x1 = f x2) = (x1 = x2)) & (ALL x. f x ~= z)"
-
-lemma DEF_IND_SUC: "IND_SUC =
-(SOME f. EX z. (ALL x1 x2. (f x1 = f x2) = (x1 = x2)) & (ALL x. f x ~= z))"
-  by (import hollight DEF_IND_SUC)
-
-definition
-  IND_0 :: "ind"  where
-  "IND_0 ==
-SOME z.
-   (ALL x1 x2. (IND_SUC x1 = IND_SUC x2) = (x1 = x2)) &
-   (ALL x. IND_SUC x ~= z)"
-
-lemma DEF_IND_0: "IND_0 =
-(SOME z.
-    (ALL x1 x2. (IND_SUC x1 = IND_SUC x2) = (x1 = x2)) &
-    (ALL x. IND_SUC x ~= z))"
-  by (import hollight DEF_IND_0)
-
-definition
-  NUM_REP :: "ind => bool"  where
-  "NUM_REP ==
-%a. ALL NUM_REP'.
-       (ALL a.
-           a = IND_0 | (EX i. a = IND_SUC i & NUM_REP' i) -->
-           NUM_REP' a) -->
-       NUM_REP' a"
-
-lemma DEF_NUM_REP: "NUM_REP =
-(%a. ALL NUM_REP'.
-        (ALL a.
-            a = IND_0 | (EX i. a = IND_SUC i & NUM_REP' i) -->
-            NUM_REP' a) -->
-        NUM_REP' a)"
-  by (import hollight DEF_NUM_REP)
-
-lemma num_RECURSION_STD: "EX fn::nat => 'Z.
-   fn (0::nat) = (e::'Z) &
-   (ALL n::nat. fn (Suc n) = (f::nat => 'Z => 'Z) n (fn n))"
-  by (import hollight num_RECURSION_STD)
-
-lemma ADD_CLAUSES: "(ALL x::nat. (0::nat) + x = x) &
-(ALL x::nat. x + (0::nat) = x) &
-(ALL (x::nat) xa::nat. Suc x + xa = Suc (x + xa)) &
-(ALL (x::nat) xa::nat. x + Suc xa = Suc (x + xa))"
-  by (import hollight ADD_CLAUSES)
-
-lemma ADD_AC: "(m::nat) + (n::nat) = n + m &
-m + n + (p::nat) = m + (n + p) & m + (n + p) = n + (m + p)"
-  by (import hollight ADD_AC)
-
-lemma EQ_ADD_LCANCEL_0: "((m::nat) + (n::nat) = m) = (n = (0::nat))"
-  by (import hollight EQ_ADD_LCANCEL_0)
-
-lemma EQ_ADD_RCANCEL_0: "((x::nat) + (xa::nat) = xa) = (x = (0::nat))"
-  by (import hollight EQ_ADD_RCANCEL_0)
-
-lemma BIT1: "2 * x + 1 = Suc (x + x)"
-  by (import hollight BIT1)
-
-lemma BIT1_THM: "2 * x + 1 = Suc (x + x)"
-  by (import hollight BIT1_THM)
-
-lemma TWO: "2 = Suc 1"
-  by (import hollight TWO)
-
-lemma MULT_CLAUSES: "(ALL x::nat. (0::nat) * x = (0::nat)) &
-(ALL x::nat. x * (0::nat) = (0::nat)) &
-(ALL x::nat. (1::nat) * x = x) &
-(ALL x::nat. x * (1::nat) = x) &
-(ALL (x::nat) xa::nat. Suc x * xa = x * xa + xa) &
-(ALL (x::nat) xa::nat. x * Suc xa = x + x * xa)"
-  by (import hollight MULT_CLAUSES)
-
-lemma MULT_AC: "(m::nat) * (n::nat) = n * m &
-m * n * (p::nat) = m * (n * p) & m * (n * p) = n * (m * p)"
-  by (import hollight MULT_AC)
-
-lemma EXP_EQ_1: "((x::nat) ^ (n::nat) = (1::nat)) = (x = (1::nat) | n = (0::nat))"
-  by (import hollight EXP_EQ_1)
-
-lemma LT_ANTISYM: "~ ((m::nat) < (n::nat) & n < m)"
-  by (import hollight LT_ANTISYM)
-
-lemma LET_ANTISYM: "~ ((m::nat) <= (n::nat) & n < m)"
-  by (import hollight LET_ANTISYM)
-
-lemma LTE_ANTISYM: "~ ((x::nat) < (xa::nat) & xa <= x)"
-  by (import hollight LTE_ANTISYM)
-
-lemma LT_CASES: "(m::nat) < (n::nat) | n < m | m = n"
-  by (import hollight LT_CASES)
-
-lemma LTE_CASES: "(x::nat) < (xa::nat) | xa <= x"
-  by (import hollight LTE_CASES)
-
-lemma LE_1: "(ALL x::nat. x ~= (0::nat) --> (0::nat) < x) &
-(ALL x::nat. x ~= (0::nat) --> (1::nat) <= x) &
-(ALL x>0::nat. x ~= (0::nat)) &
-(ALL x>0::nat. (1::nat) <= x) &
-(ALL x>=1::nat. (0::nat) < x) & (ALL x>=1::nat. x ~= (0::nat))"
-  by (import hollight LE_1)
-
-lemma LT_EXISTS: "(m < n) = (EX d. n = m + Suc d)"
-  by (import hollight LT_EXISTS)
-
-lemma LT_ADD: "((m::nat) < m + (n::nat)) = ((0::nat) < n)"
-  by (import hollight LT_ADD)
-
-lemma LT_ADDR: "((xa::nat) < (x::nat) + xa) = ((0::nat) < x)"
-  by (import hollight LT_ADDR)
-
-lemma LT_LMULT: "(m::nat) ~= (0::nat) & (n::nat) < (p::nat) ==> m * n < m * p"
-  by (import hollight LT_LMULT)
-
-lemma LE_MULT_LCANCEL: "((m::nat) * (n::nat) <= m * (p::nat)) = (m = (0::nat) | n <= p)"
-  by (import hollight LE_MULT_LCANCEL)
-
-lemma LE_MULT_RCANCEL: "((x::nat) * (xb::nat) <= (xa::nat) * xb) = (x <= xa | xb = (0::nat))"
-  by (import hollight LE_MULT_RCANCEL)
-
-lemma LT_MULT_LCANCEL: "((m::nat) * (n::nat) < m * (p::nat)) = (m ~= (0::nat) & n < p)"
-  by (import hollight LT_MULT_LCANCEL)
-
-lemma LT_MULT_RCANCEL: "((x::nat) * (xb::nat) < (xa::nat) * xb) = (x < xa & xb ~= (0::nat))"
-  by (import hollight LT_MULT_RCANCEL)
-
-lemma LT_MULT2: "(m::nat) < (n::nat) & (p::nat) < (q::nat) ==> m * p < n * q"
-  by (import hollight LT_MULT2)
-
-lemma WLOG_LE: "(ALL (m::nat) n::nat. (P::nat => nat => bool) m n = P n m) &
-(ALL (m::nat) n::nat. m <= n --> P m n)
-==> P (m::nat) (x::nat)"
-  by (import hollight WLOG_LE)
-
-lemma WLOG_LT: "(ALL m::nat. (P::nat => nat => bool) m m) &
-(ALL (m::nat) n::nat. P m n = P n m) &
-(ALL (m::nat) n::nat. m < n --> P m n)
-==> P (m::nat) (x::nat)"
-  by (import hollight WLOG_LT)
-
-lemma num_WOP: "Ex (P::nat => bool) = (EX n::nat. P n & (ALL m<n. ~ P m))"
-  by (import hollight num_WOP)
-
-lemma num_MAX: "(Ex (P::nat => bool) & (EX M::nat. ALL x::nat. P x --> x <= M)) =
-(EX m::nat. P m & (ALL x::nat. P x --> x <= m))"
-  by (import hollight num_MAX)
-
-lemma NOT_EVEN: "odd (n::nat) = odd n"
-  by (import hollight NOT_EVEN)
-
-lemma NOT_ODD: "(~ odd (n::nat)) = even n"
-  by (import hollight NOT_ODD)
-
-lemma EVEN_OR_ODD: "even (n::nat) | odd n"
-  by (import hollight EVEN_OR_ODD)
-
-lemma EVEN_AND_ODD: "~ (even (x::nat) & odd x)"
-  by (import hollight EVEN_AND_ODD)
-
-lemma EVEN_EXP: "even ((m::nat) ^ (n::nat)) = (even m & n ~= (0::nat))"
-  by (import hollight EVEN_EXP)
-
-lemma ODD_MULT: "odd ((m::nat) * (n::nat)) = (odd m & odd n)"
-  by (import hollight ODD_MULT)
-
-lemma ODD_EXP: "odd ((m::nat) ^ (n::nat)) = (odd m | n = (0::nat))"
-  by (import hollight ODD_EXP)
-
-lemma EVEN_DOUBLE: "even ((2::nat) * (n::nat))"
-  by (import hollight EVEN_DOUBLE)
-
-lemma ODD_DOUBLE: "odd (Suc (2 * x))"
-  by (import hollight ODD_DOUBLE)
-
-lemma EVEN_EXISTS_LEMMA: "(even n --> (EX m. n = 2 * m)) & (odd n --> (EX m. n = Suc (2 * m)))"
-  by (import hollight EVEN_EXISTS_LEMMA)
-
-lemma EVEN_ODD_DECOMPOSITION: "(EX (k::nat) m::nat. odd m & (n::nat) = (2::nat) ^ k * m) = (n ~= (0::nat))"
-  by (import hollight EVEN_ODD_DECOMPOSITION)
-
-lemma SUB_0: "(0::nat) - (x::nat) = (0::nat) & x - (0::nat) = x"
-  by (import hollight SUB_0)
-
-lemma SUB_PRESUC: "Suc m - n - Suc 0 = m - n"
-  by (import hollight SUB_PRESUC)
-
-lemma ADD_SUBR: "(xa::nat) - ((x::nat) + xa) = (0::nat)"
-  by (import hollight ADD_SUBR)
-
-lemma EVEN_SUB: "even ((m::nat) - (n::nat)) = (m <= n | even m = even n)"
-  by (import hollight EVEN_SUB)
-
-lemma ODD_SUB: "odd ((x::nat) - (xa::nat)) = (xa < x & odd x ~= odd xa)"
-  by (import hollight ODD_SUB)
-
-lemma EXP_LT_0: "((0::nat) < (xa::nat) ^ (x::nat)) = (xa ~= (0::nat) | x = (0::nat))"
-  by (import hollight EXP_LT_0)
-
-lemma LT_EXP: "((x::nat) ^ (m::nat) < x ^ (n::nat)) =
-((2::nat) <= x & m < n | x = (0::nat) & m ~= (0::nat) & n = (0::nat))"
-  by (import hollight LT_EXP)
-
-lemma LE_EXP: "((x::nat) ^ (m::nat) <= x ^ (n::nat)) =
-(if x = (0::nat) then m = (0::nat) --> n = (0::nat)
- else x = (1::nat) | m <= n)"
-  by (import hollight LE_EXP)
-
-lemma EQ_EXP: "((x::nat) ^ (m::nat) = x ^ (n::nat)) =
-(if x = (0::nat) then (m = (0::nat)) = (n = (0::nat))
- else x = (1::nat) | m = n)"
-  by (import hollight EQ_EXP)
-
-lemma EXP_MONO_LE_IMP: "(x::nat) <= (xa::nat) ==> x ^ (xb::nat) <= xa ^ xb"
-  by (import hollight EXP_MONO_LE_IMP)
-
-lemma EXP_MONO_LT_IMP: "(x::nat) < (y::nat) & (n::nat) ~= (0::nat) ==> x ^ n < y ^ n"
-  by (import hollight EXP_MONO_LT_IMP)
-
-lemma EXP_MONO_LE: "((x::nat) ^ (n::nat) <= (y::nat) ^ n) = (x <= y | n = (0::nat))"
-  by (import hollight EXP_MONO_LE)
-
-lemma EXP_MONO_LT: "((x::nat) ^ (xb::nat) < (xa::nat) ^ xb) = (x < xa & xb ~= (0::nat))"
-  by (import hollight EXP_MONO_LT)
-
-lemma EXP_MONO_EQ: "((x::nat) ^ (xb::nat) = (xa::nat) ^ xb) = (x = xa | xb = (0::nat))"
-  by (import hollight EXP_MONO_EQ)
-
-lemma DIVMOD_EXIST: "(n::nat) ~= (0::nat) ==> EX (q::nat) r::nat. (m::nat) = q * n + r & r < n"
-  by (import hollight DIVMOD_EXIST)
-
-lemma DIVMOD_EXIST_0: "EX (x::nat) xa::nat.
-   if (n::nat) = (0::nat) then x = (0::nat) & xa = (m::nat)
-   else m = x * n + xa & xa < n"
-  by (import hollight DIVMOD_EXIST_0)
-
-lemma DIVISION: "(n::nat) ~= (0::nat) ==> (m::nat) = m div n * n + m mod n & m mod n < n"
-  by (import hollight DIVISION)
-
-lemma DIVMOD_UNIQ_LEMMA: "((m::nat) = (q1::nat) * (n::nat) + (r1::nat) & r1 < n) &
-m = (q2::nat) * n + (r2::nat) & r2 < n
-==> q1 = q2 & r1 = r2"
-  by (import hollight DIVMOD_UNIQ_LEMMA)
-
-lemma DIVMOD_UNIQ: "(m::nat) = (q::nat) * (n::nat) + (r::nat) & r < n
-==> m div n = q & m mod n = r"
-  by (import hollight DIVMOD_UNIQ)
-
-lemma MOD_UNIQ: "(m::nat) = (q::nat) * (n::nat) + (r::nat) & r < n ==> m mod n = r"
-  by (import hollight MOD_UNIQ)
-
-lemma DIV_UNIQ: "(m::nat) = (q::nat) * (n::nat) + (r::nat) & r < n ==> m div n = q"
-  by (import hollight DIV_UNIQ)
-
-lemma MOD_EQ: "(m::nat) = (n::nat) + (q::nat) * (p::nat) ==> m mod p = n mod p"
-  by (import hollight MOD_EQ)
-
-lemma DIV_LE: "(n::nat) ~= (0::nat) ==> (m::nat) div n <= m"
-  by (import hollight DIV_LE)
-
-lemma DIV_MUL_LE: "(n::nat) * ((m::nat) div n) <= m"
-  by (import hollight DIV_MUL_LE)
-
-lemma MOD_MOD: "(n::nat) * (p::nat) ~= (0::nat) ==> (m::nat) mod (n * p) mod n = m mod n"
-  by (import hollight MOD_MOD)
-
-lemma MOD_MOD_REFL: "(n::nat) ~= (0::nat) ==> (m::nat) mod n mod n = m mod n"
-  by (import hollight MOD_MOD_REFL)
-
-lemma DIV_MULT2: "(x::nat) * (xb::nat) ~= (0::nat) ==> x * (xa::nat) div (x * xb) = xa div xb"
-  by (import hollight DIV_MULT2)
-
-lemma MOD_MULT2: "(x::nat) * (xb::nat) ~= (0::nat)
-==> x * (xa::nat) mod (x * xb) = x * (xa mod xb)"
-  by (import hollight MOD_MULT2)
-
-lemma MOD_EXISTS: "(EX q::nat. (m::nat) = (n::nat) * q) =
-(if n = (0::nat) then m = (0::nat) else m mod n = (0::nat))"
-  by (import hollight MOD_EXISTS)
-
-lemma LE_RDIV_EQ: "(a::nat) ~= (0::nat) ==> ((n::nat) <= (b::nat) div a) = (a * n <= b)"
-  by (import hollight LE_RDIV_EQ)
-
-lemma LE_LDIV_EQ: "(a::nat) ~= (0::nat)
-==> ((b::nat) div a <= (n::nat)) = (b < a * (n + (1::nat)))"
-  by (import hollight LE_LDIV_EQ)
-
-lemma LE_LDIV: "(x::nat) ~= (0::nat) & (xa::nat) <= x * (xb::nat) ==> xa div x <= xb"
-  by (import hollight LE_LDIV)
-
-lemma DIV_MONO: "(p::nat) ~= (0::nat) & (m::nat) <= (n::nat) ==> m div p <= n div p"
-  by (import hollight DIV_MONO)
-
-lemma DIV_MONO_LT: "(p::nat) ~= (0::nat) & (m::nat) + p <= (n::nat) ==> m div p < n div p"
-  by (import hollight DIV_MONO_LT)
-
-lemma DIV_EQ_0: "(n::nat) ~= (0::nat) ==> ((m::nat) div n = (0::nat)) = (m < n)"
-  by (import hollight DIV_EQ_0)
-
-lemma MOD_EQ_0: "(n::nat) ~= (0::nat)
-==> ((m::nat) mod n = (0::nat)) = (EX q::nat. m = q * n)"
-  by (import hollight MOD_EQ_0)
-
-lemma EVEN_MOD: "even (n::nat) = (n mod (2::nat) = (0::nat))"
-  by (import hollight EVEN_MOD)
-
-lemma ODD_MOD: "odd (n::nat) = (n mod (2::nat) = (1::nat))"
-  by (import hollight ODD_MOD)
-
-lemma MOD_MULT_RMOD: "(n::nat) ~= (0::nat) ==> (m::nat) * ((p::nat) mod n) mod n = m * p mod n"
-  by (import hollight MOD_MULT_RMOD)
-
-lemma MOD_MULT_LMOD: "(xa::nat) ~= (0::nat) ==> (x::nat) mod xa * (xb::nat) mod xa = x * xb mod xa"
-  by (import hollight MOD_MULT_LMOD)
-
-lemma MOD_MULT_MOD2: "(xa::nat) ~= (0::nat)
-==> (x::nat) mod xa * ((xb::nat) mod xa) mod xa = x * xb mod xa"
-  by (import hollight MOD_MULT_MOD2)
-
-lemma MOD_EXP_MOD: "(n::nat) ~= (0::nat) ==> ((m::nat) mod n) ^ (p::nat) mod n = m ^ p mod n"
-  by (import hollight MOD_EXP_MOD)
-
-lemma MOD_ADD_MOD: "(n::nat) ~= (0::nat)
-==> ((a::nat) mod n + (b::nat) mod n) mod n = (a + b) mod n"
-  by (import hollight MOD_ADD_MOD)
-
-lemma DIV_ADD_MOD: "(n::nat) ~= (0::nat)
-==> (((a::nat) + (b::nat)) mod n = a mod n + b mod n) =
-    ((a + b) div n = a div n + b div n)"
-  by (import hollight DIV_ADD_MOD)
-
-lemma MOD_LE: "(n::nat) ~= (0::nat) ==> (m::nat) mod n <= m"
-  by (import hollight MOD_LE)
-
-lemma DIV_MONO2: "(p::nat) ~= (0::nat) & p <= (m::nat) ==> (n::nat) div m <= n div p"
-  by (import hollight DIV_MONO2)
-
-lemma DIV_LE_EXCLUSION: "(b::nat) ~= (0::nat) & b * (c::nat) < ((a::nat) + (1::nat)) * (d::nat)
-==> c div d <= a div b"
-  by (import hollight DIV_LE_EXCLUSION)
-
-lemma DIV_EQ_EXCLUSION: "(b::nat) * (c::nat) < ((a::nat) + (1::nat)) * (d::nat) &
-a * d < (c + (1::nat)) * b
-==> a div b = c div d"
-  by (import hollight DIV_EQ_EXCLUSION)
-
-lemma MULT_DIV_LE: "(p::nat) ~= (0::nat) ==> (m::nat) * ((n::nat) div p) <= m * n div p"
-  by (import hollight MULT_DIV_LE)
-
-lemma DIV_DIV: "(xa::nat) * (xb::nat) ~= (0::nat)
-==> (x::nat) div xa div xb = x div (xa * xb)"
-  by (import hollight DIV_DIV)
-
-lemma DIV_MOD: "(xa::nat) * (xb::nat) ~= (0::nat)
-==> (x::nat) div xa mod xb = x mod (xa * xb) div xa"
-  by (import hollight DIV_MOD)
-
-lemma PRE_ELIM_THM: "P (n - Suc 0) = (ALL m. n = Suc m | m = 0 & n = 0 --> P m)"
-  by (import hollight PRE_ELIM_THM)
-
-lemma SUB_ELIM_THM: "(P::nat => bool) ((a::nat) - (b::nat)) =
-(ALL d::nat. a = b + d | a < b & d = (0::nat) --> P d)"
-  by (import hollight SUB_ELIM_THM)
-
-lemma DIVMOD_ELIM_THM: "(P::nat => nat => bool) ((m::nat) div (n::nat)) (m mod n) =
-(ALL (x::nat) xa::nat.
-    n = (0::nat) & x = (0::nat) & xa = m | m = x * n + xa & xa < n -->
-    P x xa)"
-  by (import hollight DIVMOD_ELIM_THM)
-
-definition
-  minimal :: "(nat => bool) => nat"  where
-  "minimal == %u. SOME n. u n & (ALL m<n. ~ u m)"
-
-lemma DEF_minimal: "minimal = (%u. SOME n. u n & (ALL m<n. ~ u m))"
-  by (import hollight DEF_minimal)
-
-lemma MINIMAL: "Ex P = (P (minimal P) & (ALL x<minimal P. ~ P x))"
-  by (import hollight MINIMAL)
-
-lemma TRANSITIVE_STEPWISE_LT_EQ: "(!!x y z. R x y & R y z ==> R x z)
-==> (ALL m n. m < n --> R m n) = (ALL n. R n (Suc n))"
-  by (import hollight TRANSITIVE_STEPWISE_LT_EQ)
-
-lemma TRANSITIVE_STEPWISE_LT: "[| (ALL x y z. R x y & R y z --> R x z) & (ALL n. R n (Suc n)); m < n |]
-==> R m n"
-  by (import hollight TRANSITIVE_STEPWISE_LT)
-
-lemma TRANSITIVE_STEPWISE_LE_EQ: "(ALL x. R x x) & (ALL x y z. R x y & R y z --> R x z)
-==> (ALL m n. m <= n --> R m n) = (ALL n. R n (Suc n))"
-  by (import hollight TRANSITIVE_STEPWISE_LE_EQ)
-
-lemma TRANSITIVE_STEPWISE_LE: "[| (ALL x. R x x) &
-   (ALL x y z. R x y & R y z --> R x z) & (ALL n. R n (Suc n));
-   m <= n |]
-==> R m n"
-  by (import hollight TRANSITIVE_STEPWISE_LE)
-
-lemma WF_EQ: "wfP (u_556::'A => 'A => bool) =
-(ALL P::'A => bool.
-    Ex P = (EX x::'A. P x & (ALL y::'A. u_556 y x --> ~ P y)))"
-  by (import hollight WF_EQ)
-
-lemma WF_IND: "wfP (u_556::'A => 'A => bool) =
-(ALL P::'A => bool.
-    (ALL x::'A. (ALL y::'A. u_556 y x --> P y) --> P x) --> All P)"
-  by (import hollight WF_IND)
-
-lemma WF_DCHAIN: "wfP (u_556::'A => 'A => bool) =
-(~ (EX s::nat => 'A. ALL n::nat. u_556 (s (Suc n)) (s n)))"
-  by (import hollight WF_DCHAIN)
-
-lemma WF_UREC: "[| wfP (u_556::'A => 'A => bool);
-   !!(f::'A => 'B) (g::'A => 'B) x::'A.
-      (!!z::'A. u_556 z x ==> f z = g z)
-      ==> (H::('A => 'B) => 'A => 'B) f x = H g x;
-   (ALL x::'A. (f::'A => 'B) x = H f x) &
-   (ALL x::'A. (g::'A => 'B) x = H g x) |]
-==> f = g"
-  by (import hollight WF_UREC)
-
-lemma WF_UREC_WF: "(!!(H::('A => bool) => 'A => bool) (f::'A => bool) g::'A => bool.
-    [| !!(f::'A => bool) (g::'A => bool) x::'A.
-          (!!z::'A. (u_556::'A => 'A => bool) z x ==> f z = g z)
-          ==> H f x = H g x;
-       (ALL x::'A. f x = H f x) & (ALL x::'A. g x = H g x) |]
-    ==> f = g)
-==> wfP u_556"
-  by (import hollight WF_UREC_WF)
-
-lemma WF_REC_INVARIANT: "[| wfP (u_556::'A => 'A => bool);
-   !!(f::'A => 'B) (g::'A => 'B) x::'A.
-      (!!z::'A. u_556 z x ==> f z = g z & (S::'A => 'B => bool) z (f z))
-      ==> (H::('A => 'B) => 'A => 'B) f x = H g x & S x (H f x) |]
-==> EX f::'A => 'B. ALL x::'A. f x = H f x"
-  by (import hollight WF_REC_INVARIANT)
-
-lemma WF_REC: "[| wfP (u_556::'A => 'A => bool);
-   !!(f::'A => 'B) (g::'A => 'B) x::'A.
-      (!!z::'A. u_556 z x ==> f z = g z)
-      ==> (H::('A => 'B) => 'A => 'B) f x = H g x |]
-==> EX f::'A => 'B. ALL x::'A. f x = H f x"
-  by (import hollight WF_REC)
-
-lemma WF_REC_WF: "(!!H::('A => nat) => 'A => nat.
-    (!!(f::'A => nat) (g::'A => nat) x::'A.
-        (!!z::'A. (u_556::'A => 'A => bool) z x ==> f z = g z)
-        ==> H f x = H g x)
-    ==> EX f::'A => nat. ALL x::'A. f x = H f x)
-==> wfP u_556"
-  by (import hollight WF_REC_WF)
-
-lemma WF_EREC: "[| wfP (u_556::'A => 'A => bool);
-   !!(f::'A => 'B) (g::'A => 'B) x::'A.
-      (!!z::'A. u_556 z x ==> f z = g z)
-      ==> (H::('A => 'B) => 'A => 'B) f x = H g x |]
-==> EX! f::'A => 'B. ALL x::'A. f x = H f x"
-  by (import hollight WF_EREC)
-
-lemma WF_SUBSET: "(ALL (x::'A) y::'A.
-    (u_556::'A => 'A => bool) x y --> (u_670::'A => 'A => bool) x y) &
-wfP u_670
-==> wfP u_556"
-  by (import hollight WF_SUBSET)
-
-lemma WF_MEASURE_GEN: "wfP (u_556::'B => 'B => bool)
-==> wfP (%(x::'A) x'::'A. u_556 ((m::'A => 'B) x) (m x'))"
-  by (import hollight WF_MEASURE_GEN)
-
-lemma WF_LEX_DEPENDENT: "wfP (R::'A => 'A => bool) & (ALL x::'A. wfP ((S::'A => 'B => 'B => bool) x))
-==> wfP (SOME f::'A * 'B => 'A * 'B => bool.
-            ALL (r1::'A) s1::'B.
-               f (r1, s1) =
-               (SOME f::'A * 'B => bool.
-                   ALL (r2::'A) s2::'B.
-                      f (r2, s2) = (R r1 r2 | r1 = r2 & S r1 s1 s2)))"
-  by (import hollight WF_LEX_DEPENDENT)
-
-lemma WF_LEX: "wfP (x::'A => 'A => bool) & wfP (xa::'B => 'B => bool)
-==> wfP (SOME f::'A * 'B => 'A * 'B => bool.
-            ALL (r1::'A) s1::'B.
-               f (r1, s1) =
-               (SOME f::'A * 'B => bool.
-                   ALL (r2::'A) s2::'B.
-                      f (r2, s2) = (x r1 r2 | r1 = r2 & xa s1 s2)))"
-  by (import hollight WF_LEX)
-
-lemma WF_POINTWISE: "wfP (u_556::'A => 'A => bool) & wfP (u_670::'B => 'B => bool)
-==> wfP (SOME f::'A * 'B => 'A * 'B => bool.
-            ALL (x1::'A) y1::'B.
-               f (x1, y1) =
-               (SOME f::'A * 'B => bool.
-                   ALL (x2::'A) y2::'B.
-                      f (x2, y2) = (u_556 x1 x2 & u_670 y1 y2)))"
-  by (import hollight WF_POINTWISE)
-
-lemma WF_num: "(wfP::(nat => nat => bool) => bool) (op <::nat => nat => bool)"
-  by (import hollight WF_num)
-
-lemma WF_REC_num: "(!!(f::nat => 'A) (g::nat => 'A) x::nat.
-    (!!z::nat. z < x ==> f z = g z)
-    ==> (H::(nat => 'A) => nat => 'A) f x = H g x)
-==> EX f::nat => 'A. ALL x::nat. f x = H f x"
-  by (import hollight WF_REC_num)
-
-lemma WF_MEASURE: "wfP (%(a::'A) b::'A. (a, b) : measure (m::'A => nat))"
-  by (import hollight WF_MEASURE)
-
-lemma MEASURE_LE: "(ALL x::'q_12099.
-    (x, a::'q_12099) : measure (m::'q_12099 => nat) -->
-    (x, b::'q_12099) : measure m) =
-(m a <= m b)"
-  by (import hollight MEASURE_LE)
-
-lemma WF_REFL: "wfP (u_556::'A => 'A => bool) ==> ~ u_556 (x::'A) x"
-  by (import hollight WF_REFL)
-
-lemma WF_REC_TAIL: "EX f::'A => 'B.
-   ALL x::'A.
-      f x =
-      (if (P::'A => bool) x then f ((g::'A => 'A) x) else (h::'A => 'B) x)"
-  by (import hollight WF_REC_TAIL)
-
-lemma WF_REC_TAIL_GENERAL: "wfP (u_556::'A => 'A => bool) &
-(ALL (f::'A => 'B) (g::'A => 'B) x::'A.
-    (ALL z::'A. u_556 z x --> f z = g z) -->
-    (P::('A => 'B) => 'A => bool) f x = P g x &
-    (G::('A => 'B) => 'A => 'A) f x = G g x &
-    (H::('A => 'B) => 'A => 'B) f x = H g x) &
-(ALL (f::'A => 'B) (g::'A => 'B) x::'A.
-    (ALL z::'A. u_556 z x --> f z = g z) --> H f x = H g x) &
-(ALL (f::'A => 'B) (x::'A) y::'A. P f x & u_556 y (G f x) --> u_556 y x)
-==> EX f::'A => 'B. ALL x::'A. f x = (if P f x then f (G f x) else H f x)"
-  by (import hollight WF_REC_TAIL_GENERAL)
-
-lemma ARITH_ZERO: "(0::nat) = (0::nat) & (0::nat) = (0::nat)"
-  by (import hollight ARITH_ZERO)
-
-lemma ARITH_SUC: "(ALL x. Suc x = Suc x) &
-Suc 0 = 1 &
-(ALL x. Suc (2 * x) = 2 * x + 1) & (ALL x. Suc (2 * x + 1) = 2 * Suc x)"
-  by (import hollight ARITH_SUC)
-
-lemma ARITH_PRE: "(ALL x. x - Suc 0 = x - Suc 0) &
-0 - Suc 0 = 0 &
-(ALL x. 2 * x - Suc 0 = (if x = 0 then 0 else 2 * (x - Suc 0) + 1)) &
-(ALL x. 2 * x + 1 - Suc 0 = 2 * x)"
-  by (import hollight ARITH_PRE)
-
-lemma ARITH_ADD: "(ALL (x::nat) xa::nat. x + xa = x + xa) &
-(0::nat) + (0::nat) = (0::nat) &
-(ALL x::nat. (0::nat) + (2::nat) * x = (2::nat) * x) &
-(ALL x::nat.
-    (0::nat) + ((2::nat) * x + (1::nat)) = (2::nat) * x + (1::nat)) &
-(ALL x::nat. (2::nat) * x + (0::nat) = (2::nat) * x) &
-(ALL x::nat. (2::nat) * x + (1::nat) + (0::nat) = (2::nat) * x + (1::nat)) &
-(ALL (x::nat) xa::nat. (2::nat) * x + (2::nat) * xa = (2::nat) * (x + xa)) &
-(ALL (x::nat) xa::nat.
-    (2::nat) * x + ((2::nat) * xa + (1::nat)) =
-    (2::nat) * (x + xa) + (1::nat)) &
-(ALL (x::nat) xa::nat.
-    (2::nat) * x + (1::nat) + (2::nat) * xa =
-    (2::nat) * (x + xa) + (1::nat)) &
-(ALL (x::nat) xa::nat.
-    (2::nat) * x + (1::nat) + ((2::nat) * xa + (1::nat)) =
-    (2::nat) * Suc (x + xa))"
-  by (import hollight ARITH_ADD)
-
-lemma ARITH_MULT: "(ALL (x::nat) xa::nat. x * xa = x * xa) &
-(0::nat) * (0::nat) = (0::nat) &
-(ALL x::nat. (0::nat) * ((2::nat) * x) = (0::nat)) &
-(ALL x::nat. (0::nat) * ((2::nat) * x + (1::nat)) = (0::nat)) &
-(ALL x::nat. (2::nat) * x * (0::nat) = (0::nat)) &
-(ALL x::nat. ((2::nat) * x + (1::nat)) * (0::nat) = (0::nat)) &
-(ALL (x::nat) xa::nat.
-    (2::nat) * x * ((2::nat) * xa) = (2::nat) * ((2::nat) * (x * xa))) &
-(ALL (x::nat) xa::nat.
-    (2::nat) * x * ((2::nat) * xa + (1::nat)) =
-    (2::nat) * x + (2::nat) * ((2::nat) * (x * xa))) &
-(ALL (x::nat) xa::nat.
-    ((2::nat) * x + (1::nat)) * ((2::nat) * xa) =
-    (2::nat) * xa + (2::nat) * ((2::nat) * (x * xa))) &
-(ALL (x::nat) xa::nat.
-    ((2::nat) * x + (1::nat)) * ((2::nat) * xa + (1::nat)) =
-    (2::nat) * x + (1::nat) +
-    ((2::nat) * xa + (2::nat) * ((2::nat) * (x * xa))))"
-  by (import hollight ARITH_MULT)
-
-lemma ARITH_EXP: "(ALL (x::nat) xa::nat. x ^ xa = x ^ xa) &
-(0::nat) ^ (0::nat) = (1::nat) &
-(ALL m::nat. ((2::nat) * m) ^ (0::nat) = (1::nat)) &
-(ALL m::nat. ((2::nat) * m + (1::nat)) ^ (0::nat) = (1::nat)) &
-(ALL n::nat. (0::nat) ^ ((2::nat) * n) = (0::nat) ^ n * (0::nat) ^ n) &
-(ALL (m::nat) n::nat.
-    ((2::nat) * m) ^ ((2::nat) * n) =
-    ((2::nat) * m) ^ n * ((2::nat) * m) ^ n) &
-(ALL (m::nat) n::nat.
-    ((2::nat) * m + (1::nat)) ^ ((2::nat) * n) =
-    ((2::nat) * m + (1::nat)) ^ n * ((2::nat) * m + (1::nat)) ^ n) &
-(ALL n::nat. (0::nat) ^ ((2::nat) * n + (1::nat)) = (0::nat)) &
-(ALL (m::nat) n::nat.
-    ((2::nat) * m) ^ ((2::nat) * n + (1::nat)) =
-    (2::nat) * m * (((2::nat) * m) ^ n * ((2::nat) * m) ^ n)) &
-(ALL (m::nat) n::nat.
-    ((2::nat) * m + (1::nat)) ^ ((2::nat) * n + (1::nat)) =
-    ((2::nat) * m + (1::nat)) *
-    (((2::nat) * m + (1::nat)) ^ n * ((2::nat) * m + (1::nat)) ^ n))"
-  by (import hollight ARITH_EXP)
-
-lemma ARITH_EVEN: "(ALL x::nat. even x = even x) &
-even (0::nat) = True &
-(ALL x::nat. even ((2::nat) * x) = True) &
-(ALL x::nat. even ((2::nat) * x + (1::nat)) = False)"
-  by (import hollight ARITH_EVEN)
-
-lemma ARITH_ODD: "(ALL x::nat. odd x = odd x) &
-odd (0::nat) = False &
-(ALL x::nat. odd ((2::nat) * x) = False) &
-(ALL x::nat. odd ((2::nat) * x + (1::nat)) = True)"
-  by (import hollight ARITH_ODD)
-
-lemma ARITH_LE: "(ALL (x::nat) xa::nat. (x <= xa) = (x <= xa)) &
-((0::nat) <= (0::nat)) = True &
-(ALL x::nat. ((2::nat) * x <= (0::nat)) = (x <= (0::nat))) &
-(ALL x::nat. ((2::nat) * x + (1::nat) <= (0::nat)) = False) &
-(ALL x::nat. ((0::nat) <= (2::nat) * x) = True) &
-(ALL x::nat. ((0::nat) <= (2::nat) * x + (1::nat)) = True) &
-(ALL (x::nat) xa::nat. ((2::nat) * x <= (2::nat) * xa) = (x <= xa)) &
-(ALL (x::nat) xa::nat.
-    ((2::nat) * x <= (2::nat) * xa + (1::nat)) = (x <= xa)) &
-(ALL (x::nat) xa::nat.
-    ((2::nat) * x + (1::nat) <= (2::nat) * xa) = (x < xa)) &
-(ALL (x::nat) xa::nat.
-    ((2::nat) * x + (1::nat) <= (2::nat) * xa + (1::nat)) = (x <= xa))"
-  by (import hollight ARITH_LE)
-
-lemma ARITH_LT: "(ALL (x::nat) xa::nat. (x < xa) = (x < xa)) &
-((0::nat) < (0::nat)) = False &
-(ALL x::nat. ((2::nat) * x < (0::nat)) = False) &
-(ALL x::nat. ((2::nat) * x + (1::nat) < (0::nat)) = False) &
-(ALL x::nat. ((0::nat) < (2::nat) * x) = ((0::nat) < x)) &
-(ALL x::nat. ((0::nat) < (2::nat) * x + (1::nat)) = True) &
-(ALL (x::nat) xa::nat. ((2::nat) * x < (2::nat) * xa) = (x < xa)) &
-(ALL (x::nat) xa::nat.
-    ((2::nat) * x < (2::nat) * xa + (1::nat)) = (x <= xa)) &
-(ALL (x::nat) xa::nat.
-    ((2::nat) * x + (1::nat) < (2::nat) * xa) = (x < xa)) &
-(ALL (x::nat) xa::nat.
-    ((2::nat) * x + (1::nat) < (2::nat) * xa + (1::nat)) = (x < xa))"
-  by (import hollight ARITH_LT)
-
-lemma ARITH_EQ: "(ALL (x::nat) xa::nat. (x = xa) = (x = xa)) &
-((0::nat) = (0::nat)) = True &
-(ALL x::nat. ((2::nat) * x = (0::nat)) = (x = (0::nat))) &
-(ALL x::nat. ((2::nat) * x + (1::nat) = (0::nat)) = False) &
-(ALL x::nat. ((0::nat) = (2::nat) * x) = ((0::nat) = x)) &
-(ALL x::nat. ((0::nat) = (2::nat) * x + (1::nat)) = False) &
-(ALL (x::nat) xa::nat. ((2::nat) * x = (2::nat) * xa) = (x = xa)) &
-(ALL (x::nat) xa::nat. ((2::nat) * x = (2::nat) * xa + (1::nat)) = False) &
-(ALL (x::nat) xa::nat. ((2::nat) * x + (1::nat) = (2::nat) * xa) = False) &
-(ALL (x::nat) xa::nat.
-    ((2::nat) * x + (1::nat) = (2::nat) * xa + (1::nat)) = (x = xa))"
-  by (import hollight ARITH_EQ)
-
-lemma ARITH_SUB: "(ALL (x::nat) xa::nat. x - xa = x - xa) &
-(0::nat) - (0::nat) = (0::nat) &
-(ALL x::nat. (0::nat) - (2::nat) * x = (0::nat)) &
-(ALL x::nat. (0::nat) - ((2::nat) * x + (1::nat)) = (0::nat)) &
-(ALL x::nat. (2::nat) * x - (0::nat) = (2::nat) * x) &
-(ALL x::nat. (2::nat) * x + (1::nat) - (0::nat) = (2::nat) * x + (1::nat)) &
-(ALL (m::nat) n::nat. (2::nat) * m - (2::nat) * n = (2::nat) * (m - n)) &
-(ALL (m::nat) n::nat.
-    (2::nat) * m - ((2::nat) * n + (1::nat)) =
-    (2::nat) * (m - n) - Suc (0::nat)) &
-(ALL (m::nat) n::nat.
-    (2::nat) * m + (1::nat) - (2::nat) * n =
-    (if n <= m then (2::nat) * (m - n) + (1::nat) else (0::nat))) &
-(ALL (m::nat) n::nat.
-    (2::nat) * m + (1::nat) - ((2::nat) * n + (1::nat)) =
-    (2::nat) * (m - n))"
-  by (import hollight ARITH_SUB)
-
-lemma right_th: "(s::nat) * ((2::nat) * (x::nat) + (1::nat)) = s + (2::nat) * (s * x)"
-  by (import hollight right_th)
-
-lemma SEMIRING_PTHS: "(ALL (x::'A) (y::'A) z::'A.
-    (add::'A => 'A => 'A) x (add y z) = add (add x y) z) &
-(ALL (x::'A) y::'A. add x y = add y x) &
-(ALL x::'A. add (r0::'A) x = x) &
-(ALL (x::'A) (y::'A) z::'A.
-    (mul::'A => 'A => 'A) x (mul y z) = mul (mul x y) z) &
-(ALL (x::'A) y::'A. mul x y = mul y x) &
-(ALL x::'A. mul (r1::'A) x = x) &
-(ALL x::'A. mul r0 x = r0) &
-(ALL (x::'A) (y::'A) z::'A. mul x (add y z) = add (mul x y) (mul x z)) &
-(ALL x::'A. (pwr::'A => nat => 'A) x (0::nat) = r1) &
-(ALL (x::'A) n::nat. pwr x (Suc n) = mul x (pwr x n))
-==> mul r1 (x::'A) = x &
-    add (mul (a::'A) (m::'A)) (mul (b::'A) m) = mul (add a b) m &
-    add (mul a m) m = mul (add a r1) m &
-    add m (mul a m) = mul (add a r1) m &
-    add m m = mul (add r1 r1) m &
-    mul r0 m = r0 &
-    add r0 a = a &
-    add a r0 = a &
-    mul a b = mul b a &
-    mul (add a b) (c::'A) = add (mul a c) (mul b c) &
-    mul r0 a = r0 &
-    mul a r0 = r0 &
-    mul r1 a = a &
-    mul a r1 = a &
-    mul (mul (lx::'A) (ly::'A)) (mul (rx::'A) (ry::'A)) =
-    mul (mul lx rx) (mul ly ry) &
-    mul (mul lx ly) (mul rx ry) = mul lx (mul ly (mul rx ry)) &
-    mul (mul lx ly) (mul rx ry) = mul rx (mul (mul lx ly) ry) &
-    mul (mul lx ly) rx = mul (mul lx rx) ly &
-    mul (mul lx ly) rx = mul lx (mul ly rx) &
-    mul lx rx = mul rx lx &
-    mul lx (mul rx ry) = mul (mul lx rx) ry &
-    mul lx (mul rx ry) = mul rx (mul lx ry) &
-    add (add a b) (add c (d::'A)) = add (add a c) (add b d) &
-    add (add a b) c = add a (add b c) &
-    add a (add c d) = add c (add a d) &
-    add (add a b) c = add (add a c) b &
-    add a c = add c a &
-    add a (add c d) = add (add a c) d &
-    mul (pwr x (p::nat)) (pwr x (q::nat)) = pwr x (p + q) &
-    mul x (pwr x q) = pwr x (Suc q) &
-    mul (pwr x q) x = pwr x (Suc q) &
-    mul x x = pwr x (2::nat) &
-    pwr (mul x (y::'A)) q = mul (pwr x q) (pwr y q) &
-    pwr (pwr x p) q = pwr x (p * q) &
-    pwr x (0::nat) = r1 &
-    pwr x (1::nat) = x &
-    mul x (add y (z::'A)) = add (mul x y) (mul x z) &
-    pwr x (Suc q) = mul x (pwr x q)"
-  by (import hollight SEMIRING_PTHS)
-
-lemma NUM_INTEGRAL_LEMMA: "(w::nat) = (x::nat) + (d::nat) & (y::nat) = (z::nat) + (e::nat)
-==> (w * y + x * z = w * z + x * y) = (w = x | y = z)"
-  by (import hollight NUM_INTEGRAL_LEMMA)
-
-lemma NUM_INTEGRAL: "(ALL x::nat. (0::nat) * x = (0::nat)) &
-(ALL (x::nat) (xa::nat) xb::nat. (x + xa = x + xb) = (xa = xb)) &
-(ALL (w::nat) (x::nat) (y::nat) z::nat.
-    (w * y + x * z = w * z + x * y) = (w = x | y = z))"
-  by (import hollight NUM_INTEGRAL)
-
-lemma INJ_INVERSE2: "(!!(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"
-  by (import hollight INJ_INVERSE2)
-
-definition
-  NUMPAIR :: "nat => nat => nat"  where
-  "NUMPAIR == %u ua. 2 ^ u * (2 * ua + 1)"
-
-lemma DEF_NUMPAIR: "NUMPAIR = (%u ua. 2 ^ u * (2 * ua + 1))"
-  by (import hollight DEF_NUMPAIR)
-
-lemma NUMPAIR_INJ_LEMMA: "NUMPAIR x xa = NUMPAIR xb xc ==> x = xb"
-  by (import hollight NUMPAIR_INJ_LEMMA)
-
-lemma NUMPAIR_INJ: "(NUMPAIR x1 y1 = NUMPAIR x2 y2) = (x1 = x2 & y1 = y2)"
-  by (import hollight NUMPAIR_INJ)
-
-definition
-  NUMFST :: "nat => nat"  where
-  "NUMFST == SOME X. EX Y. ALL x y. X (NUMPAIR x y) = x & Y (NUMPAIR x y) = y"
-
-lemma DEF_NUMFST: "NUMFST = (SOME X. EX Y. ALL x y. X (NUMPAIR x y) = x & Y (NUMPAIR x y) = y)"
-  by (import hollight DEF_NUMFST)
-
-definition
-  NUMSND :: "nat => nat"  where
-  "NUMSND == SOME Y. ALL x y. NUMFST (NUMPAIR x y) = x & Y (NUMPAIR x y) = y"
-
-lemma DEF_NUMSND: "NUMSND = (SOME Y. ALL x y. NUMFST (NUMPAIR x y) = x & Y (NUMPAIR x y) = y)"
-  by (import hollight DEF_NUMSND)
-
-definition
-  NUMSUM :: "bool => nat => nat"  where
-  "NUMSUM == %u ua. if u then Suc (2 * ua) else 2 * ua"
-
-lemma DEF_NUMSUM: "NUMSUM = (%u ua. if u then Suc (2 * ua) else 2 * ua)"
-  by (import hollight DEF_NUMSUM)
-
-lemma NUMSUM_INJ: "(NUMSUM b1 x1 = NUMSUM b2 x2) = (b1 = b2 & x1 = x2)"
-  by (import hollight NUMSUM_INJ)
-
-definition
-  NUMLEFT :: "nat => bool"  where
-  "NUMLEFT == SOME X. EX Y. ALL x y. X (NUMSUM x y) = x & Y (NUMSUM x y) = y"
-
-lemma DEF_NUMLEFT: "NUMLEFT = (SOME X. EX Y. ALL x y. X (NUMSUM x y) = x & Y (NUMSUM x y) = y)"
-  by (import hollight DEF_NUMLEFT)
-
-definition
-  NUMRIGHT :: "nat => nat"  where
-  "NUMRIGHT == SOME Y. ALL x y. NUMLEFT (NUMSUM x y) = x & Y (NUMSUM x y) = y"
-
-lemma DEF_NUMRIGHT: "NUMRIGHT = (SOME Y. ALL x y. NUMLEFT (NUMSUM x y) = x & Y (NUMSUM x y) = y)"
-  by (import hollight DEF_NUMRIGHT)
-
-definition
-  INJN :: "nat => nat => 'A => bool"  where
-  "INJN == %(u::nat) (n::nat) a::'A. n = u"
-
-lemma DEF_INJN: "INJN = (%(u::nat) (n::nat) a::'A. n = u)"
-  by (import hollight DEF_INJN)
-
-lemma INJN_INJ: "(op =::bool => bool => bool)
- ((op =::(nat => 'A::type => bool) => (nat => 'A::type => bool) => bool)
-   ((INJN::nat => nat => 'A::type => bool) (n1::nat))
-   ((INJN::nat => nat => 'A::type => bool) (n2::nat)))
- ((op =::nat => nat => bool) n1 n2)"
-  by (import hollight INJN_INJ)
-
-definition
-  INJA :: "'A => nat => 'A => bool"  where
-  "INJA == %(u::'A) (n::nat) b::'A. b = u"
-
-lemma DEF_INJA: "INJA = (%(u::'A) (n::nat) b::'A. b = u)"
-  by (import hollight DEF_INJA)
-
-lemma INJA_INJ: "(INJA (a1::'A) = INJA (a2::'A)) = (a1 = a2)"
-  by (import hollight INJA_INJ)
-
-definition
-  INJF :: "(nat => nat => 'A => bool) => nat => 'A => bool"  where
-  "INJF == %(u::nat => nat => 'A => bool) n::nat. u (NUMFST n) (NUMSND n)"
-
-lemma DEF_INJF: "INJF = (%(u::nat => nat => 'A => bool) n::nat. u (NUMFST n) (NUMSND n))"
-  by (import hollight DEF_INJF)
-
-lemma INJF_INJ: "(INJF (f1::nat => nat => 'A => bool) =
- INJF (f2::nat => nat => 'A => bool)) =
-(f1 = f2)"
-  by (import hollight INJF_INJ)
-
-definition
-  INJP :: "(nat => 'A => bool) => (nat => 'A => bool) => nat => 'A => bool"  where
-  "INJP ==
-%(u::nat => 'A => bool) (ua::nat => 'A => bool) (n::nat) a::'A.
-   if NUMLEFT n then u (NUMRIGHT n) a else ua (NUMRIGHT n) a"
-
-lemma DEF_INJP: "INJP =
-(%(u::nat => 'A => bool) (ua::nat => 'A => bool) (n::nat) a::'A.
-    if NUMLEFT n then u (NUMRIGHT n) a else ua (NUMRIGHT n) a)"
-  by (import hollight DEF_INJP)
-
-lemma INJP_INJ: "(INJP (f1::nat => 'A => bool) (f2::nat => 'A => bool) =
- INJP (f1'::nat => 'A => bool) (f2'::nat => 'A => bool)) =
-(f1 = f1' & f2 = f2')"
-  by (import hollight INJP_INJ)
-
-definition
-  ZCONSTR :: "nat => 'A => (nat => nat => 'A => bool) => nat => 'A => bool"  where
-  "ZCONSTR ==
-%(u::nat) (ua::'A) ub::nat => nat => 'A => bool.
-   INJP (INJN (Suc u)) (INJP (INJA ua) (INJF ub))"
-
-lemma DEF_ZCONSTR: "ZCONSTR =
-(%(u::nat) (ua::'A) ub::nat => nat => 'A => bool.
-    INJP (INJN (Suc u)) (INJP (INJA ua) (INJF ub)))"
-  by (import hollight DEF_ZCONSTR)
-
-definition
-  ZBOT :: "nat => 'A => bool"  where
-  "ZBOT == INJP (INJN (0::nat)) (SOME z::nat => 'A => bool. True)"
-
-lemma DEF_ZBOT: "ZBOT = INJP (INJN (0::nat)) (SOME z::nat => 'A => bool. True)"
-  by (import hollight DEF_ZBOT)
-
-lemma ZCONSTR_ZBOT: "ZCONSTR (x::nat) (xa::'A) (xb::nat => nat => 'A => bool) ~= ZBOT"
-  by (import hollight ZCONSTR_ZBOT)
-
-definition
-  ZRECSPACE :: "(nat => 'A => bool) => bool"  where
-  "ZRECSPACE ==
-%a::nat => 'A => bool.
-   ALL ZRECSPACE'::(nat => 'A => bool) => bool.
-      (ALL a::nat => 'A => bool.
-          a = ZBOT |
-          (EX (c::nat) (i::'A) r::nat => nat => 'A => bool.
-              a = ZCONSTR c i r & (ALL n::nat. ZRECSPACE' (r n))) -->
-          ZRECSPACE' a) -->
-      ZRECSPACE' a"
-
-lemma DEF_ZRECSPACE: "ZRECSPACE =
-(%a::nat => 'A => bool.
-    ALL ZRECSPACE'::(nat => 'A => bool) => bool.
-       (ALL a::nat => 'A => bool.
-           a = ZBOT |
-           (EX (c::nat) (i::'A) r::nat => nat => 'A => bool.
-               a = ZCONSTR c i r & (ALL n::nat. ZRECSPACE' (r n))) -->
-           ZRECSPACE' a) -->
-       ZRECSPACE' a)"
-  by (import hollight DEF_ZRECSPACE)
-
-typedef (open) 'a recspace = "Collect ZRECSPACE :: (nat \<Rightarrow> 'a \<Rightarrow> bool) set" 
-  morphisms "_dest_rec" "_mk_rec"
-  apply (rule light_ex_imp_nonempty [where t="ZBOT"])
-  by (import hollight TYDEF_recspace)
-
-syntax
-  "_dest_rec" :: _ ("'_dest'_rec")
-
-syntax
-  "_mk_rec" :: _ ("'_mk'_rec")
-
-lemmas "TYDEF_recspace_@intern" = typedef_hol2hollight 
-  [where a="a :: 'A recspace" and r=r ,
-   OF type_definition_recspace]
-
-definition
-  BOTTOM :: "'A recspace"  where
-  "BOTTOM == _mk_rec ZBOT"
-
-lemma DEF_BOTTOM: "BOTTOM = _mk_rec ZBOT"
-  by (import hollight DEF_BOTTOM)
-
-definition
-  CONSTR :: "nat => 'A => (nat => 'A recspace) => 'A recspace"  where
-  "CONSTR ==
-%(u::nat) (ua::'A::type) ub::nat => 'A::type recspace.
-   _mk_rec (ZCONSTR u ua (%n::nat. _dest_rec (ub n)))"
-
-lemma DEF_CONSTR: "CONSTR =
-(%(u::nat) (ua::'A::type) ub::nat => 'A::type recspace.
-    _mk_rec (ZCONSTR u ua (%n::nat. _dest_rec (ub n))))"
-  by (import hollight DEF_CONSTR)
-
-lemma MK_REC_INJ: "[| _mk_rec (x::nat => 'A::type => bool) =
-   _mk_rec (y::nat => 'A::type => bool);
-   ZRECSPACE x & ZRECSPACE y |]
-==> x = y"
-  by (import hollight MK_REC_INJ)
-
-lemma CONSTR_BOT: "CONSTR (c::nat) (i::'A) (r::nat => 'A recspace) ~= BOTTOM"
-  by (import hollight CONSTR_BOT)
-
-lemma CONSTR_INJ: "(CONSTR (c1::nat) (i1::'A) (r1::nat => 'A recspace) =
- CONSTR (c2::nat) (i2::'A) (r2::nat => 'A recspace)) =
-(c1 = c2 & i1 = i2 & r1 = r2)"
-  by (import hollight CONSTR_INJ)
-
-lemma CONSTR_IND: "(P::'A recspace => bool) BOTTOM &
-(ALL (c::nat) (i::'A) r::nat => 'A recspace.
-    (ALL n::nat. P (r n)) --> P (CONSTR c i r))
-==> P (x::'A recspace)"
-  by (import hollight CONSTR_IND)
-
-lemma CONSTR_REC: "EX f::'A recspace => 'B.
-   ALL (c::nat) (i::'A) r::nat => 'A recspace.
-      f (CONSTR c i r) =
-      (Fn::nat => 'A => (nat => 'A recspace) => (nat => 'B) => 'B) c i r
-       (%n::nat. f (r n))"
-  by (import hollight CONSTR_REC)
-
-definition
-  FCONS :: "'A => (nat => 'A) => nat => 'A"  where
-  "FCONS ==
-SOME FCONS::'A => (nat => 'A) => nat => 'A.
-   (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)"
-
-lemma DEF_FCONS: "FCONS =
-(SOME FCONS::'A => (nat => 'A) => nat => 'A.
-    (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))"
-  by (import hollight DEF_FCONS)
-
-lemma FCONS_UNDO: "(f::nat => 'A) = FCONS (f (0::nat)) (f o Suc)"
-  by (import hollight FCONS_UNDO)
-
-definition
-  FNIL :: "nat => 'A"  where
-  "FNIL == %u::nat. SOME x::'A. True"
-
-lemma DEF_FNIL: "FNIL = (%u::nat. SOME x::'A. True)"
-  by (import hollight DEF_FNIL)
-
-definition
-  ISO :: "('A => 'B) => ('B => 'A) => bool"  where
-  "ISO ==
-%(u::'A => 'B) ua::'B => 'A.
-   (ALL x::'B. u (ua x) = x) & (ALL y::'A. ua (u y) = y)"
-
-lemma DEF_ISO: "ISO =
-(%(u::'A => 'B) ua::'B => 'A.
-    (ALL x::'B. u (ua x) = x) & (ALL y::'A. ua (u y) = y))"
-  by (import hollight DEF_ISO)
-
-lemma ISO_REFL: "ISO (%x::'A. x) (%x::'A. x)"
-  by (import hollight ISO_REFL)
-
-lemma ISO_FUN: "ISO (f::'A => 'A') (f'::'A' => 'A) & ISO (g::'B => 'B') (g'::'B' => 'B)
-==> ISO (%(h::'A => 'B) a'::'A'. g (h (f' a')))
-     (%(h::'A' => 'B') a::'A. g' (h (f a)))"
-  by (import hollight ISO_FUN)
-
-lemma ISO_USAGE: "ISO (f::'q_17485 => 'q_17482) (g::'q_17482 => 'q_17485)
-==> (ALL P::'q_17485 => bool. All P = (ALL x::'q_17482. P (g x))) &
-    (ALL P::'q_17485 => bool. Ex P = (EX x::'q_17482. P (g x))) &
-    (ALL (a::'q_17485) b::'q_17482. (a = g b) = (f a = b))"
-  by (import hollight ISO_USAGE)
-
-typedef (open) char = "{a. ALL char'.
-       (ALL a.
-           (EX a0 a1 a2 a3 a4 a5 a6 a7.
-               a =
-               CONSTR (NUMERAL 0) (a0 :: bool, a1 :: bool, a2 :: bool, a3 :: bool, a4 :: bool, a5 :: bool, a6 :: bool, a7:: bool)
-                (%n. BOTTOM)) -->
-           char' a) -->
-       char' a}"
-  morphisms "_dest_char" "_mk_char"
-  apply (rule light_ex_imp_nonempty [where t="CONSTR (NUMERAL 0) (a0, a1, a2, a3, a4, a5, a6, a7) (%n. BOTTOM)"])
-  by (import hollight TYDEF_char)
-
-syntax
-  "_dest_char" :: _ ("'_dest'_char")
-
-syntax
-  "_mk_char" :: _ ("'_mk'_char")
-
-lemmas "TYDEF_char_@intern" = typedef_hol2hollight 
-  [where a="a :: hollight.char" and r=r ,
-   OF type_definition_char]
-
-consts
-  "_11937" :: "bool
-=> bool => bool => bool => bool => bool => bool => bool => hollight.char" ("'_11937")
-
-defs
-  "_11937_def": "_11937 ==
-%(a0::bool) (a1::bool) (a2::bool) (a3::bool) (a4::bool) (a5::bool)
-   (a6::bool) a7::bool.
-   _mk_char
-    (CONSTR (0::nat) (a0, a1, a2, a3, a4, a5, a6, a7) (%n::nat. BOTTOM))"
-
-lemma DEF__11937: "_11937 =
-(%(a0::bool) (a1::bool) (a2::bool) (a3::bool) (a4::bool) (a5::bool)
-    (a6::bool) a7::bool.
-    _mk_char
-     (CONSTR (0::nat) (a0, a1, a2, a3, a4, a5, a6, a7) (%n::nat. BOTTOM)))"
-  by (import hollight DEF__11937)
-
-definition
-  ASCII :: "bool
-=> bool => bool => bool => bool => bool => bool => bool => hollight.char"  where
-  "ASCII == _11937"
-
-lemma DEF_ASCII: "ASCII = _11937"
-  by (import hollight DEF_ASCII)
-
-consts
-  dist :: "nat * nat => nat" 
-
-defs
-  dist_def: "hollight.dist == %u. fst u - snd u + (snd u - fst u)"
-
-lemma DEF_dist: "hollight.dist = (%u. fst u - snd u + (snd u - fst u))"
-  by (import hollight DEF_dist)
-
-lemma DIST_REFL: "hollight.dist (x, x) = 0"
-  by (import hollight DIST_REFL)
-
-lemma DIST_LZERO: "hollight.dist (0, x) = x"
-  by (import hollight DIST_LZERO)
-
-lemma DIST_RZERO: "hollight.dist (x, 0) = x"
-  by (import hollight DIST_RZERO)
-
-lemma DIST_SYM: "hollight.dist (x, xa) = hollight.dist (xa, x)"
-  by (import hollight DIST_SYM)
-
-lemma DIST_LADD: "hollight.dist (x + xb, x + xa) = hollight.dist (xb, xa)"
-  by (import hollight DIST_LADD)
-
-lemma DIST_RADD: "hollight.dist (x + xa, xb + xa) = hollight.dist (x, xb)"
-  by (import hollight DIST_RADD)
-
-lemma DIST_LADD_0: "hollight.dist (x + xa, x) = xa"
-  by (import hollight DIST_LADD_0)
-
-lemma DIST_RADD_0: "hollight.dist (x, x + xa) = xa"
-  by (import hollight DIST_RADD_0)
-
-lemma DIST_LMUL: "x * hollight.dist (xa, xb) = hollight.dist (x * xa, x * xb)"
-  by (import hollight DIST_LMUL)
-
-lemma DIST_RMUL: "hollight.dist (x, xa) * xb = hollight.dist (x * xb, xa * xb)"
-  by (import hollight DIST_RMUL)
-
-lemma DIST_EQ_0: "(hollight.dist (x, xa) = 0) = (x = xa)"
-  by (import hollight DIST_EQ_0)
-
-lemma DIST_ELIM_THM: "P (hollight.dist (x, y)) =
-(ALL d. (x = y + d --> P d) & (y = x + d --> P d))"
-  by (import hollight DIST_ELIM_THM)
-
-lemma DIST_LE_CASES: "(hollight.dist (m, n) <= p) = (m <= n + p & n <= m + p)"
-  by (import hollight DIST_LE_CASES)
-
-lemma DIST_TRIANGLE_LE: "hollight.dist (m, n) + hollight.dist (n, p) <= q
-==> hollight.dist (m, p) <= q"
-  by (import hollight DIST_TRIANGLE_LE)
-
-lemma DIST_TRIANGLES_LE: "hollight.dist (m, n) <= r & hollight.dist (p, q) <= s
-==> hollight.dist (m, p) <= hollight.dist (n, q) + (r + s)"
-  by (import hollight DIST_TRIANGLES_LE)
-
-lemma BOUNDS_LINEAR: "(ALL n::nat. (A::nat) * n <= (B::nat) * n + (C::nat)) = (A <= B)"
-  by (import hollight BOUNDS_LINEAR)
-
-lemma BOUNDS_LINEAR_0: "(ALL n::nat. (A::nat) * n <= (B::nat)) = (A = (0::nat))"
-  by (import hollight BOUNDS_LINEAR_0)
-
-lemma BOUNDS_DIVIDED: "(EX B::nat. ALL n::nat. (P::nat => nat) n <= B) =
-(EX (x::nat) B::nat. ALL n::nat. n * P n <= x * n + B)"
-  by (import hollight BOUNDS_DIVIDED)
-
-lemma BOUNDS_NOTZERO: "(P::nat => nat => nat) (0::nat) (0::nat) = (0::nat) &
-(ALL (m::nat) n::nat. P m n <= (A::nat) * (m + n) + (B::nat))
-==> EX x::nat. ALL (m::nat) n::nat. P m n <= x * (m + n)"
-  by (import hollight BOUNDS_NOTZERO)
-
-lemma BOUNDS_IGNORE: "(EX B::nat. ALL i::nat. (P::nat => nat) i <= (Q::nat => nat) i + B) =
-(EX (x::nat) N::nat. ALL i>=N. P i <= Q i + x)"
-  by (import hollight BOUNDS_IGNORE)
-
-definition
-  is_nadd :: "(nat => nat) => bool"  where
-  "is_nadd ==
-%u. EX B. ALL m n. hollight.dist (m * u n, n * u m) <= B * (m + n)"
-
-lemma DEF_is_nadd: "is_nadd =
-(%u. EX B. ALL m n. hollight.dist (m * u n, n * u m) <= B * (m + n))"
-  by (import hollight DEF_is_nadd)
-
-lemma is_nadd_0: "is_nadd (%n. 0)"
-  by (import hollight is_nadd_0)
-
-typedef (open) nadd = "Collect is_nadd"  morphisms "dest_nadd" "mk_nadd"
-  apply (rule light_ex_imp_nonempty[where t="%n. NUMERAL 0"])
-  by (import hollight TYDEF_nadd)
-
-syntax
-  dest_nadd :: _ 
-
-syntax
-  mk_nadd :: _ 
-
-lemmas "TYDEF_nadd_@intern" = typedef_hol2hollight 
-  [where a="a :: nadd" and r=r ,
-   OF type_definition_nadd]
-
-lemma NADD_CAUCHY: "EX xa.
-   ALL xb xc.
-      hollight.dist (xb * dest_nadd x xc, xc * dest_nadd x xb)
-      <= xa * (xb + xc)"
-  by (import hollight NADD_CAUCHY)
-
-lemma NADD_BOUND: "EX xa B. ALL n. dest_nadd x n <= xa * n + B"
-  by (import hollight NADD_BOUND)
-
-lemma NADD_MULTIPLICATIVE: "EX xa.
-   ALL m n.
-      hollight.dist (dest_nadd x (m * n), m * dest_nadd x n) <= xa * m + xa"
-  by (import hollight NADD_MULTIPLICATIVE)
-
-lemma NADD_ADDITIVE: "EX xa.
-   ALL m n.
-      hollight.dist (dest_nadd x (m + n), dest_nadd x m + dest_nadd x n)
-      <= xa"
-  by (import hollight NADD_ADDITIVE)
-
-lemma NADD_SUC: "EX xa. ALL n. hollight.dist (dest_nadd x (Suc n), dest_nadd x n) <= xa"
-  by (import hollight NADD_SUC)
-
-lemma NADD_DIST_LEMMA: "EX xa. ALL m n. hollight.dist (dest_nadd x (m + n), dest_nadd x m) <= xa * n"
-  by (import hollight NADD_DIST_LEMMA)
-
-lemma NADD_DIST: "EX xa.
-   ALL m n.
-      hollight.dist (dest_nadd x m, dest_nadd x n)
-      <= xa * hollight.dist (m, n)"
-  by (import hollight NADD_DIST)
-
-lemma NADD_ALTMUL: "EX A B.
-   ALL n.
-      hollight.dist
-       (n * dest_nadd x (dest_nadd y n), dest_nadd x n * dest_nadd y n)
-      <= A * n + B"
-  by (import hollight NADD_ALTMUL)
-
-definition
-  nadd_eq :: "nadd => nadd => bool"  where
-  "nadd_eq ==
-%u ua. EX B. ALL n. hollight.dist (dest_nadd u n, dest_nadd ua n) <= B"
-
-lemma DEF_nadd_eq: "nadd_eq =
-(%u ua. EX B. ALL n. hollight.dist (dest_nadd u n, dest_nadd ua n) <= B)"
-  by (import hollight DEF_nadd_eq)
-
-lemma NADD_EQ_REFL: "nadd_eq x x"
-  by (import hollight NADD_EQ_REFL)
-
-lemma NADD_EQ_SYM: "nadd_eq x y = nadd_eq y x"
-  by (import hollight NADD_EQ_SYM)
-
-lemma NADD_EQ_TRANS: "nadd_eq x y & nadd_eq y z ==> nadd_eq x z"
-  by (import hollight NADD_EQ_TRANS)
-
-definition
-  nadd_of_num :: "nat => nadd"  where
-  "nadd_of_num == %u. mk_nadd (op * u)"
-
-lemma DEF_nadd_of_num: "nadd_of_num = (%u. mk_nadd (op * u))"
-  by (import hollight DEF_nadd_of_num)
-
-lemma NADD_OF_NUM: "dest_nadd (nadd_of_num x) = op * x"
-  by (import hollight NADD_OF_NUM)
-
-lemma NADD_OF_NUM_WELLDEF: "m = n ==> nadd_eq (nadd_of_num m) (nadd_of_num n)"
-  by (import hollight NADD_OF_NUM_WELLDEF)
-
-lemma NADD_OF_NUM_EQ: "nadd_eq (nadd_of_num m) (nadd_of_num n) = (m = n)"
-  by (import hollight NADD_OF_NUM_EQ)
-
-definition
-  nadd_le :: "nadd => nadd => bool"  where
-  "nadd_le == %u ua. EX B. ALL n. dest_nadd u n <= dest_nadd ua n + B"
-
-lemma DEF_nadd_le: "nadd_le = (%u ua. EX B. ALL n. dest_nadd u n <= dest_nadd ua n + B)"
-  by (import hollight DEF_nadd_le)
-
-lemma NADD_LE_WELLDEF_LEMMA: "nadd_eq x x' & nadd_eq y y' & nadd_le x y ==> nadd_le x' y'"
-  by (import hollight NADD_LE_WELLDEF_LEMMA)
-
-lemma NADD_LE_WELLDEF: "nadd_eq x x' & nadd_eq y y' ==> nadd_le x y = nadd_le x' y'"
-  by (import hollight NADD_LE_WELLDEF)
-
-lemma NADD_LE_REFL: "nadd_le x x"
-  by (import hollight NADD_LE_REFL)
-
-lemma NADD_LE_TRANS: "nadd_le x y & nadd_le y z ==> nadd_le x z"
-  by (import hollight NADD_LE_TRANS)
-
-lemma NADD_LE_ANTISYM: "(nadd_le x y & nadd_le y x) = nadd_eq x y"
-  by (import hollight NADD_LE_ANTISYM)
-
-lemma NADD_LE_TOTAL_LEMMA: "~ nadd_le x y ==> EX n. n ~= 0 & dest_nadd y n + B < dest_nadd x n"
-  by (import hollight NADD_LE_TOTAL_LEMMA)
-
-lemma NADD_LE_TOTAL: "nadd_le x y | nadd_le y x"
-  by (import hollight NADD_LE_TOTAL)
-
-lemma NADD_ARCH: "EX xa. nadd_le x (nadd_of_num xa)"
-  by (import hollight NADD_ARCH)
-
-lemma NADD_OF_NUM_LE: "nadd_le (nadd_of_num m) (nadd_of_num n) = (m <= n)"
-  by (import hollight NADD_OF_NUM_LE)
-
-definition
-  nadd_add :: "nadd => nadd => nadd"  where
-  "nadd_add == %u ua. mk_nadd (%n. dest_nadd u n + dest_nadd ua n)"
-
-lemma DEF_nadd_add: "nadd_add = (%u ua. mk_nadd (%n. dest_nadd u n + dest_nadd ua n))"
-  by (import hollight DEF_nadd_add)
-
-lemma NADD_ADD: "dest_nadd (nadd_add x y) = (%n. dest_nadd x n + dest_nadd y n)"
-  by (import hollight NADD_ADD)
-
-lemma NADD_ADD_WELLDEF: "nadd_eq x x' & nadd_eq y y' ==> nadd_eq (nadd_add x y) (nadd_add x' y')"
-  by (import hollight NADD_ADD_WELLDEF)
-
-lemma NADD_ADD_SYM: "nadd_eq (nadd_add x y) (nadd_add y x)"
-  by (import hollight NADD_ADD_SYM)
-
-lemma NADD_ADD_ASSOC: "nadd_eq (nadd_add x (nadd_add y z)) (nadd_add (nadd_add x y) z)"
-  by (import hollight NADD_ADD_ASSOC)
-
-lemma NADD_ADD_LID: "nadd_eq (nadd_add (nadd_of_num 0) x) x"
-  by (import hollight NADD_ADD_LID)
-
-lemma NADD_ADD_LCANCEL: "nadd_eq (nadd_add x y) (nadd_add x z) ==> nadd_eq y z"
-  by (import hollight NADD_ADD_LCANCEL)
-
-lemma NADD_LE_ADD: "nadd_le x (nadd_add x y)"
-  by (import hollight NADD_LE_ADD)
-
-lemma NADD_LE_EXISTS: "nadd_le x y ==> EX d. nadd_eq y (nadd_add x d)"
-  by (import hollight NADD_LE_EXISTS)
-
-lemma NADD_OF_NUM_ADD: "nadd_eq (nadd_add (nadd_of_num x) (nadd_of_num xa)) (nadd_of_num (x + xa))"
-  by (import hollight NADD_OF_NUM_ADD)
-
-definition
-  nadd_mul :: "nadd => nadd => nadd"  where
-  "nadd_mul == %u ua. mk_nadd (%n. dest_nadd u (dest_nadd ua n))"
-
-lemma DEF_nadd_mul: "nadd_mul = (%u ua. mk_nadd (%n. dest_nadd u (dest_nadd ua n)))"
-  by (import hollight DEF_nadd_mul)
-
-lemma NADD_MUL: "dest_nadd (nadd_mul x y) = (%n. dest_nadd x (dest_nadd y n))"
-  by (import hollight NADD_MUL)
-
-lemma NADD_MUL_SYM: "nadd_eq (nadd_mul x y) (nadd_mul y x)"
-  by (import hollight NADD_MUL_SYM)
-
-lemma NADD_MUL_ASSOC: "nadd_eq (nadd_mul x (nadd_mul y z)) (nadd_mul (nadd_mul x y) z)"
-  by (import hollight NADD_MUL_ASSOC)
-
-lemma NADD_MUL_LID: "nadd_eq (nadd_mul (nadd_of_num 1) x) x"
-  by (import hollight NADD_MUL_LID)
-
-lemma NADD_LDISTRIB: "nadd_eq (nadd_mul x (nadd_add y z)) (nadd_add (nadd_mul x y) (nadd_mul x z))"
-  by (import hollight NADD_LDISTRIB)
-
-lemma NADD_MUL_WELLDEF_LEMMA: "nadd_eq y y' ==> nadd_eq (nadd_mul x y) (nadd_mul x y')"
-  by (import hollight NADD_MUL_WELLDEF_LEMMA)
-
-lemma NADD_MUL_WELLDEF: "nadd_eq x x' & nadd_eq y y' ==> nadd_eq (nadd_mul x y) (nadd_mul x' y')"
-  by (import hollight NADD_MUL_WELLDEF)
-
-lemma NADD_OF_NUM_MUL: "nadd_eq (nadd_mul (nadd_of_num x) (nadd_of_num xa)) (nadd_of_num (x * xa))"
-  by (import hollight NADD_OF_NUM_MUL)
-
-lemma NADD_LE_0: "nadd_le (nadd_of_num 0) x"
-  by (import hollight NADD_LE_0)
-
-lemma NADD_EQ_IMP_LE: "nadd_eq x y ==> nadd_le x y"
-  by (import hollight NADD_EQ_IMP_LE)
-
-lemma NADD_LE_LMUL: "nadd_le y z ==> nadd_le (nadd_mul x y) (nadd_mul x z)"
-  by (import hollight NADD_LE_LMUL)
-
-lemma NADD_LE_RMUL: "nadd_le x y ==> nadd_le (nadd_mul x z) (nadd_mul y z)"
-  by (import hollight NADD_LE_RMUL)
-
-lemma NADD_LE_RADD: "nadd_le (nadd_add x z) (nadd_add y z) = nadd_le x y"
-  by (import hollight NADD_LE_RADD)
-
-lemma NADD_LE_LADD: "nadd_le (nadd_add x y) (nadd_add x z) = nadd_le y z"
-  by (import hollight NADD_LE_LADD)
-
-lemma NADD_RDISTRIB: "nadd_eq (nadd_mul (nadd_add x y) z) (nadd_add (nadd_mul x z) (nadd_mul y z))"
-  by (import hollight NADD_RDISTRIB)
-
-lemma NADD_ARCH_MULT: "~ nadd_eq x (nadd_of_num 0)
-==> EX xa. nadd_le (nadd_of_num k) (nadd_mul (nadd_of_num xa) x)"
-  by (import hollight NADD_ARCH_MULT)
-
-lemma NADD_ARCH_ZERO: "(!!n. nadd_le (nadd_mul (nadd_of_num n) x) k) ==> nadd_eq x (nadd_of_num 0)"
-  by (import hollight NADD_ARCH_ZERO)
-
-lemma NADD_ARCH_LEMMA: "(!!n. nadd_le (nadd_mul (nadd_of_num n) x)
-       (nadd_add (nadd_mul (nadd_of_num n) y) z))
-==> nadd_le x y"
-  by (import hollight NADD_ARCH_LEMMA)
-
-lemma NADD_COMPLETE: "Ex P & (EX M. ALL x. P x --> nadd_le x M)
-==> EX M. (ALL x. P x --> nadd_le x M) &
-          (ALL M'. (ALL x. P x --> nadd_le x M') --> nadd_le M M')"
-  by (import hollight NADD_COMPLETE)
-
-lemma NADD_UBOUND: "EX xa N. ALL n>=N. dest_nadd x n <= xa * n"
-  by (import hollight NADD_UBOUND)
-
-lemma NADD_NONZERO: "~ nadd_eq x (nadd_of_num 0) ==> EX N. ALL n>=N. dest_nadd x n ~= 0"
-  by (import hollight NADD_NONZERO)
-
-lemma NADD_LBOUND: "~ nadd_eq x (nadd_of_num 0) ==> EX A N. ALL n>=N. n <= A * dest_nadd x n"
-  by (import hollight NADD_LBOUND)
-
-definition
-  nadd_rinv :: "nadd => nat => nat"  where
-  "nadd_rinv == %u n. n * n div dest_nadd u n"
-
-lemma DEF_nadd_rinv: "nadd_rinv = (%u n. n * n div dest_nadd u n)"
-  by (import hollight DEF_nadd_rinv)
-
-lemma NADD_MUL_LINV_LEMMA0: "~ nadd_eq x (nadd_of_num 0) ==> EX xa B. ALL i. nadd_rinv x i <= xa * i + B"
-  by (import hollight NADD_MUL_LINV_LEMMA0)
-
-lemma NADD_MUL_LINV_LEMMA1: "dest_nadd x n ~= 0
-==> hollight.dist (dest_nadd x n * nadd_rinv x n, n * n) <= dest_nadd x n"
-  by (import hollight NADD_MUL_LINV_LEMMA1)
-
-lemma NADD_MUL_LINV_LEMMA2: "~ nadd_eq x (nadd_of_num 0)
-==> EX N. ALL n>=N.
-             hollight.dist (dest_nadd x n * nadd_rinv x n, n * n)
-             <= dest_nadd x n"
-  by (import hollight NADD_MUL_LINV_LEMMA2)
-
-lemma NADD_MUL_LINV_LEMMA3: "~ nadd_eq x (nadd_of_num 0)
-==> EX N. ALL m n.
-             N <= n -->
-             hollight.dist
-              (m * (dest_nadd x m * (dest_nadd x n * nadd_rinv x n)),
-               m * (dest_nadd x m * (n * n)))
-             <= m * (dest_nadd x m * dest_nadd x n)"
-  by (import hollight NADD_MUL_LINV_LEMMA3)
-
-lemma NADD_MUL_LINV_LEMMA4: "~ nadd_eq x (nadd_of_num 0)
-==> EX N. ALL m n.
-             N <= m & N <= n -->
-             dest_nadd x m * dest_nadd x n *
-             hollight.dist (m * nadd_rinv x n, n * nadd_rinv x m)
-             <= m * n *
-                hollight.dist (m * dest_nadd x n, n * dest_nadd x m) +
-                dest_nadd x m * dest_nadd x n * (m + n)"
-  by (import hollight NADD_MUL_LINV_LEMMA4)
-
-lemma NADD_MUL_LINV_LEMMA5: "~ nadd_eq x (nadd_of_num 0)
-==> EX B N.
-       ALL m n.
-          N <= m & N <= n -->
-          dest_nadd x m * dest_nadd x n *
-          hollight.dist (m * nadd_rinv x n, n * nadd_rinv x m)
-          <= B * (m * n * (m + n))"
-  by (import hollight NADD_MUL_LINV_LEMMA5)
-
-lemma NADD_MUL_LINV_LEMMA6: "~ nadd_eq x (nadd_of_num 0)
-==> EX B N.
-       ALL m n.
-          N <= m & N <= n -->
-          m * n * hollight.dist (m * nadd_rinv x n, n * nadd_rinv x m)
-          <= B * (m * n * (m + n))"
-  by (import hollight NADD_MUL_LINV_LEMMA6)
-
-lemma NADD_MUL_LINV_LEMMA7: "~ nadd_eq x (nadd_of_num 0)
-==> EX B N.
-       ALL m n.
-          N <= m & N <= n -->
-          hollight.dist (m * nadd_rinv x n, n * nadd_rinv x m)
-          <= B * (m + n)"
-  by (import hollight NADD_MUL_LINV_LEMMA7)
-
-lemma NADD_MUL_LINV_LEMMA7a: "~ nadd_eq x (nadd_of_num 0)
-==> EX A B.
-       ALL m n.
-          m <= N -->
-          hollight.dist (m * nadd_rinv x n, n * nadd_rinv x m) <= A * n + B"
-  by (import hollight NADD_MUL_LINV_LEMMA7a)
-
-lemma NADD_MUL_LINV_LEMMA8: "~ nadd_eq x (nadd_of_num 0)
-==> EX B. ALL m n.
-             hollight.dist (m * nadd_rinv x n, n * nadd_rinv x m)
-             <= B * (m + n)"
-  by (import hollight NADD_MUL_LINV_LEMMA8)
-
-definition
-  nadd_inv :: "nadd => nadd"  where
-  "nadd_inv ==
-%u. if nadd_eq u (nadd_of_num 0) then nadd_of_num 0
-    else mk_nadd (nadd_rinv u)"
-
-lemma DEF_nadd_inv: "nadd_inv =
-(%u. if nadd_eq u (nadd_of_num 0) then nadd_of_num 0
-     else mk_nadd (nadd_rinv u))"
-  by (import hollight DEF_nadd_inv)
-
-lemma NADD_INV: "dest_nadd (nadd_inv x) =
-(if nadd_eq x (nadd_of_num 0) then %n. 0 else nadd_rinv x)"
-  by (import hollight NADD_INV)
-
-lemma NADD_MUL_LINV: "~ nadd_eq x (nadd_of_num 0)
-==> nadd_eq (nadd_mul (nadd_inv x) x) (nadd_of_num 1)"
-  by (import hollight NADD_MUL_LINV)
-
-lemma NADD_INV_0: "nadd_eq (nadd_inv (nadd_of_num 0)) (nadd_of_num 0)"
-  by (import hollight NADD_INV_0)
-
-lemma NADD_INV_WELLDEF: "nadd_eq x y ==> nadd_eq (nadd_inv x) (nadd_inv y)"
-  by (import hollight NADD_INV_WELLDEF)
-
-typedef (open) hreal = "{s. EX x. s = nadd_eq x}"  morphisms "dest_hreal" "mk_hreal"
-  apply (rule light_ex_imp_nonempty[where t="nadd_eq x"])
-  by (import hollight TYDEF_hreal)
-
-syntax
-  dest_hreal :: _ 
-
-syntax
-  mk_hreal :: _ 
-
-lemmas "TYDEF_hreal_@intern" = typedef_hol2hollight 
-  [where a="a :: hreal" and r=r ,
-   OF type_definition_hreal]
-
-definition
-  hreal_of_num :: "nat => hreal"  where
-  "hreal_of_num == %m. mk_hreal (nadd_eq (nadd_of_num m))"
-
-lemma DEF_hreal_of_num: "hreal_of_num = (%m. mk_hreal (nadd_eq (nadd_of_num m)))"
-  by (import hollight DEF_hreal_of_num)
-
-definition
-  hreal_add :: "hreal => hreal => hreal"  where
-  "hreal_add ==
-%x y. mk_hreal
-       (%u. EX xa ya.
-               nadd_eq (nadd_add xa ya) u &
-               dest_hreal x xa & dest_hreal y ya)"
-
-lemma DEF_hreal_add: "hreal_add =
-(%x y. mk_hreal
-        (%u. EX xa ya.
-                nadd_eq (nadd_add xa ya) u &
-                dest_hreal x xa & dest_hreal y ya))"
-  by (import hollight DEF_hreal_add)
-
-definition
-  hreal_mul :: "hreal => hreal => hreal"  where
-  "hreal_mul ==
-%x y. mk_hreal
-       (%u. EX xa ya.
-               nadd_eq (nadd_mul xa ya) u &
-               dest_hreal x xa & dest_hreal y ya)"
-
-lemma DEF_hreal_mul: "hreal_mul =
-(%x y. mk_hreal
-        (%u. EX xa ya.
-                nadd_eq (nadd_mul xa ya) u &
-                dest_hreal x xa & dest_hreal y ya))"
-  by (import hollight DEF_hreal_mul)
-
-definition
-  hreal_le :: "hreal => hreal => bool"  where
-  "hreal_le ==
-%x y. SOME u.
-         EX xa ya. nadd_le xa ya = u & dest_hreal x xa & dest_hreal y ya"
-
-lemma DEF_hreal_le: "hreal_le =
-(%x y. SOME u.
-          EX xa ya. nadd_le xa ya = u & dest_hreal x xa & dest_hreal y ya)"
-  by (import hollight DEF_hreal_le)
-
-definition
-  hreal_inv :: "hreal => hreal"  where
-  "hreal_inv ==
-%x. mk_hreal (%u. EX xa. nadd_eq (nadd_inv xa) u & dest_hreal x xa)"
-
-lemma DEF_hreal_inv: "hreal_inv =
-(%x. mk_hreal (%u. EX xa. nadd_eq (nadd_inv xa) u & dest_hreal x xa))"
-  by (import hollight DEF_hreal_inv)
-
-lemma HREAL_LE_EXISTS_DEF: "hreal_le m n = (EX d. n = hreal_add m d)"
-  by (import hollight HREAL_LE_EXISTS_DEF)
-
-lemma HREAL_EQ_ADD_LCANCEL: "(hreal_add m n = hreal_add m p) = (n = p)"
-  by (import hollight HREAL_EQ_ADD_LCANCEL)
-
-lemma HREAL_EQ_ADD_RCANCEL: "(hreal_add x xb = hreal_add xa xb) = (x = xa)"
-  by (import hollight HREAL_EQ_ADD_RCANCEL)
-
-lemma HREAL_LE_ADD_LCANCEL: "hreal_le (hreal_add x xa) (hreal_add x xb) = hreal_le xa xb"
-  by (import hollight HREAL_LE_ADD_LCANCEL)
-
-lemma HREAL_LE_ADD_RCANCEL: "hreal_le (hreal_add x xb) (hreal_add xa xb) = hreal_le x xa"
-  by (import hollight HREAL_LE_ADD_RCANCEL)
-
-lemma HREAL_ADD_RID: "hreal_add x (hreal_of_num 0) = x"
-  by (import hollight HREAL_ADD_RID)
-
-lemma HREAL_ADD_RDISTRIB: "hreal_mul (hreal_add x xa) xb = hreal_add (hreal_mul x xb) (hreal_mul xa xb)"
-  by (import hollight HREAL_ADD_RDISTRIB)
-
-lemma HREAL_MUL_LZERO: "hreal_mul (hreal_of_num 0) m = hreal_of_num 0"
-  by (import hollight HREAL_MUL_LZERO)
-
-lemma HREAL_MUL_RZERO: "hreal_mul x (hreal_of_num 0) = hreal_of_num 0"
-  by (import hollight HREAL_MUL_RZERO)
-
-lemma HREAL_ADD_AC: "hreal_add m n = hreal_add n m &
-hreal_add (hreal_add m n) p = hreal_add m (hreal_add n p) &
-hreal_add m (hreal_add n p) = hreal_add n (hreal_add m p)"
-  by (import hollight HREAL_ADD_AC)
-
-lemma HREAL_LE_ADD2: "hreal_le a b & hreal_le c d ==> hreal_le (hreal_add a c) (hreal_add b d)"
-  by (import hollight HREAL_LE_ADD2)
-
-lemma HREAL_LE_MUL_RCANCEL_IMP: "hreal_le a b ==> hreal_le (hreal_mul a c) (hreal_mul b c)"
-  by (import hollight HREAL_LE_MUL_RCANCEL_IMP)
-
-definition
-  treal_of_num :: "nat => hreal * hreal"  where
-  "treal_of_num == %u. (hreal_of_num u, hreal_of_num 0)"
-
-lemma DEF_treal_of_num: "treal_of_num = (%u. (hreal_of_num u, hreal_of_num 0))"
-  by (import hollight DEF_treal_of_num)
-
-definition
-  treal_neg :: "hreal * hreal => hreal * hreal"  where
-  "treal_neg == %u. (snd u, fst u)"
-
-lemma DEF_treal_neg: "treal_neg = (%u. (snd u, fst u))"
-  by (import hollight DEF_treal_neg)
-
-definition
-  treal_add :: "hreal * hreal => hreal * hreal => hreal * hreal"  where
-  "treal_add == %u ua. (hreal_add (fst u) (fst ua), hreal_add (snd u) (snd ua))"
-
-lemma DEF_treal_add: "treal_add =
-(%u ua. (hreal_add (fst u) (fst ua), hreal_add (snd u) (snd ua)))"
-  by (import hollight DEF_treal_add)
-
-definition
-  treal_mul :: "hreal * hreal => hreal * hreal => hreal * hreal"  where
-  "treal_mul ==
-%u ua.
-   (hreal_add (hreal_mul (fst u) (fst ua)) (hreal_mul (snd u) (snd ua)),
-    hreal_add (hreal_mul (fst u) (snd ua)) (hreal_mul (snd u) (fst ua)))"
-
-lemma DEF_treal_mul: "treal_mul =
-(%u ua.
-    (hreal_add (hreal_mul (fst u) (fst ua)) (hreal_mul (snd u) (snd ua)),
-     hreal_add (hreal_mul (fst u) (snd ua)) (hreal_mul (snd u) (fst ua))))"
-  by (import hollight DEF_treal_mul)
-
-definition
-  treal_le :: "hreal * hreal => hreal * hreal => bool"  where
-  "treal_le ==
-%u ua. hreal_le (hreal_add (fst u) (snd ua)) (hreal_add (fst ua) (snd u))"
-
-lemma DEF_treal_le: "treal_le =
-(%u ua. hreal_le (hreal_add (fst u) (snd ua)) (hreal_add (fst ua) (snd u)))"
-  by (import hollight DEF_treal_le)
-
-definition
-  treal_inv :: "hreal * hreal => hreal * hreal"  where
-  "treal_inv ==
-%u. if fst u = snd u then (hreal_of_num 0, hreal_of_num 0)
-    else if hreal_le (snd u) (fst u)
-         then (hreal_inv (SOME d. fst u = hreal_add (snd u) d),
-               hreal_of_num 0)
-         else (hreal_of_num 0,
-               hreal_inv (SOME d. snd u = hreal_add (fst u) d))"
-
-lemma DEF_treal_inv: "treal_inv =
-(%u. if fst u = snd u then (hreal_of_num 0, hreal_of_num 0)
-     else if hreal_le (snd u) (fst u)
-          then (hreal_inv (SOME d. fst u = hreal_add (snd u) d),
-                hreal_of_num 0)
-          else (hreal_of_num 0,
-                hreal_inv (SOME d. snd u = hreal_add (fst u) d)))"
-  by (import hollight DEF_treal_inv)
-
-definition
-  treal_eq :: "hreal * hreal => hreal * hreal => bool"  where
-  "treal_eq == %u ua. hreal_add (fst u) (snd ua) = hreal_add (fst ua) (snd u)"
-
-lemma DEF_treal_eq: "treal_eq = (%u ua. hreal_add (fst u) (snd ua) = hreal_add (fst ua) (snd u))"
-  by (import hollight DEF_treal_eq)
-
-lemma TREAL_EQ_REFL: "treal_eq x x"
-  by (import hollight TREAL_EQ_REFL)
-
-lemma TREAL_EQ_SYM: "treal_eq x y = treal_eq y x"
-  by (import hollight TREAL_EQ_SYM)
-
-lemma TREAL_EQ_TRANS: "treal_eq x y & treal_eq y z ==> treal_eq x z"
-  by (import hollight TREAL_EQ_TRANS)
-
-lemma TREAL_EQ_AP: "x = xa ==> treal_eq x xa"
-  by (import hollight TREAL_EQ_AP)
-
-lemma TREAL_OF_NUM_EQ: "treal_eq (treal_of_num x) (treal_of_num xa) = (x = xa)"
-  by (import hollight TREAL_OF_NUM_EQ)
-
-lemma TREAL_OF_NUM_LE: "treal_le (treal_of_num x) (treal_of_num xa) = (x <= xa)"
-  by (import hollight TREAL_OF_NUM_LE)
-
-lemma TREAL_OF_NUM_ADD: "treal_eq (treal_add (treal_of_num x) (treal_of_num xa))
- (treal_of_num (x + xa))"
-  by (import hollight TREAL_OF_NUM_ADD)
-
-lemma TREAL_OF_NUM_MUL: "treal_eq (treal_mul (treal_of_num x) (treal_of_num xa))
- (treal_of_num (x * xa))"
-  by (import hollight TREAL_OF_NUM_MUL)
-
-lemma TREAL_ADD_SYM_EQ: "treal_add x y = treal_add y x"
-  by (import hollight TREAL_ADD_SYM_EQ)
-
-lemma TREAL_MUL_SYM_EQ: "treal_mul x y = treal_mul y x"
-  by (import hollight TREAL_MUL_SYM_EQ)
-
-lemma TREAL_ADD_SYM: "treal_eq (treal_add x y) (treal_add y x)"
-  by (import hollight TREAL_ADD_SYM)
-
-lemma TREAL_ADD_ASSOC: "treal_eq (treal_add x (treal_add y z)) (treal_add (treal_add x y) z)"
-  by (import hollight TREAL_ADD_ASSOC)
-
-lemma TREAL_ADD_LID: "treal_eq (treal_add (treal_of_num 0) x) x"
-  by (import hollight TREAL_ADD_LID)
-
-lemma TREAL_ADD_LINV: "treal_eq (treal_add (treal_neg x) x) (treal_of_num 0)"
-  by (import hollight TREAL_ADD_LINV)
-
-lemma TREAL_MUL_SYM: "treal_eq (treal_mul x xa) (treal_mul xa x)"
-  by (import hollight TREAL_MUL_SYM)
-
-lemma TREAL_MUL_ASSOC: "treal_eq (treal_mul x (treal_mul y z)) (treal_mul (treal_mul x y) z)"
-  by (import hollight TREAL_MUL_ASSOC)
-
-lemma TREAL_MUL_LID: "treal_eq (treal_mul (treal_of_num 1) x) x"
-  by (import hollight TREAL_MUL_LID)
-
-lemma TREAL_ADD_LDISTRIB: "treal_eq (treal_mul x (treal_add y z))
- (treal_add (treal_mul x y) (treal_mul x z))"
-  by (import hollight TREAL_ADD_LDISTRIB)
-
-lemma TREAL_LE_REFL: "treal_le x x"
-  by (import hollight TREAL_LE_REFL)
-
-lemma TREAL_LE_ANTISYM: "(treal_le x y & treal_le y x) = treal_eq x y"
-  by (import hollight TREAL_LE_ANTISYM)
-
-lemma TREAL_LE_TRANS: "treal_le x y & treal_le y z ==> treal_le x z"
-  by (import hollight TREAL_LE_TRANS)
-
-lemma TREAL_LE_TOTAL: "treal_le x y | treal_le y x"
-  by (import hollight TREAL_LE_TOTAL)
-
-lemma TREAL_LE_LADD_IMP: "treal_le y z ==> treal_le (treal_add x y) (treal_add x z)"
-  by (import hollight TREAL_LE_LADD_IMP)
-
-lemma TREAL_LE_MUL: "treal_le (treal_of_num 0) x & treal_le (treal_of_num 0) y
-==> treal_le (treal_of_num 0) (treal_mul x y)"
-  by (import hollight TREAL_LE_MUL)
-
-lemma TREAL_INV_0: "treal_eq (treal_inv (treal_of_num 0)) (treal_of_num 0)"
-  by (import hollight TREAL_INV_0)
-
-lemma TREAL_MUL_LINV: "~ treal_eq x (treal_of_num 0)
-==> treal_eq (treal_mul (treal_inv x) x) (treal_of_num 1)"
-  by (import hollight TREAL_MUL_LINV)
-
-lemma TREAL_OF_NUM_WELLDEF: "m = n ==> treal_eq (treal_of_num m) (treal_of_num n)"
-  by (import hollight TREAL_OF_NUM_WELLDEF)
-
-lemma TREAL_NEG_WELLDEF: "treal_eq x1 x2 ==> treal_eq (treal_neg x1) (treal_neg x2)"
-  by (import hollight TREAL_NEG_WELLDEF)
-
-lemma TREAL_ADD_WELLDEFR: "treal_eq x1 x2 ==> treal_eq (treal_add x1 y) (treal_add x2 y)"
-  by (import hollight 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 hollight TREAL_ADD_WELLDEF)
-
-lemma TREAL_MUL_WELLDEFR: "treal_eq x1 x2 ==> treal_eq (treal_mul x1 y) (treal_mul x2 y)"
-  by (import hollight 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 hollight TREAL_MUL_WELLDEF)
-
-lemma TREAL_EQ_IMP_LE: "treal_eq x y ==> treal_le x y"
-  by (import hollight TREAL_EQ_IMP_LE)
-
-lemma TREAL_LE_WELLDEF: "treal_eq x1 x2 & treal_eq y1 y2 ==> treal_le x1 y1 = treal_le x2 y2"
-  by (import hollight TREAL_LE_WELLDEF)
-
-lemma TREAL_INV_WELLDEF: "treal_eq x y ==> treal_eq (treal_inv x) (treal_inv y)"
-  by (import hollight TREAL_INV_WELLDEF)
-
-typedef (open) real = "{s. EX x. s = treal_eq x}"  morphisms "dest_real" "mk_real"
-  apply (rule light_ex_imp_nonempty[where t="treal_eq x"])
-  by (import hollight TYDEF_real)
-
-syntax
-  dest_real :: _ 
-
-syntax
-  mk_real :: _ 
-
-lemmas "TYDEF_real_@intern" = typedef_hol2hollight 
-  [where a="a :: hollight.real" and r=r ,
-   OF type_definition_real]
-
-definition
-  real_of_num :: "nat => hollight.real"  where
-  "real_of_num == %m. mk_real (treal_eq (treal_of_num m))"
-
-lemma DEF_real_of_num: "real_of_num = (%m. mk_real (treal_eq (treal_of_num m)))"
-  by (import hollight DEF_real_of_num)
-
-definition
-  real_neg :: "hollight.real => hollight.real"  where
-  "real_neg ==
-%x1. mk_real (%u. EX x1a. treal_eq (treal_neg x1a) u & dest_real x1 x1a)"
-
-lemma DEF_real_neg: "real_neg =
-(%x1. mk_real (%u. EX x1a. treal_eq (treal_neg x1a) u & dest_real x1 x1a))"
-  by (import hollight DEF_real_neg)
-
-definition
-  real_add :: "hollight.real => hollight.real => hollight.real"  where
-  "real_add ==
-%x1 y1.
-   mk_real
-    (%u. EX x1a y1a.
-            treal_eq (treal_add x1a y1a) u &
-            dest_real x1 x1a & dest_real y1 y1a)"
-
-lemma DEF_real_add: "real_add =
-(%x1 y1.
-    mk_real
-     (%u. EX x1a y1a.
-             treal_eq (treal_add x1a y1a) u &
-             dest_real x1 x1a & dest_real y1 y1a))"
-  by (import hollight DEF_real_add)
-
-definition
-  real_mul :: "hollight.real => hollight.real => hollight.real"  where
-  "real_mul ==
-%x1 y1.
-   mk_real
-    (%u. EX x1a y1a.
-            treal_eq (treal_mul x1a y1a) u &
-            dest_real x1 x1a & dest_real y1 y1a)"
-
-lemma DEF_real_mul: "real_mul =
-(%x1 y1.
-    mk_real
-     (%u. EX x1a y1a.
-             treal_eq (treal_mul x1a y1a) u &
-             dest_real x1 x1a & dest_real y1 y1a))"
-  by (import hollight DEF_real_mul)
-
-definition
-  real_le :: "hollight.real => hollight.real => bool"  where
-  "real_le ==
-%x1 y1.
-   SOME u.
-      EX x1a y1a. treal_le x1a y1a = u & dest_real x1 x1a & dest_real y1 y1a"
-
-lemma DEF_real_le: "real_le =
-(%x1 y1.
-    SOME u.
-       EX x1a y1a.
-          treal_le x1a y1a = u & dest_real x1 x1a & dest_real y1 y1a)"
-  by (import hollight DEF_real_le)
-
-definition
-  real_inv :: "hollight.real => hollight.real"  where
-  "real_inv ==
-%x. mk_real (%u. EX xa. treal_eq (treal_inv xa) u & dest_real x xa)"
-
-lemma DEF_real_inv: "real_inv =
-(%x. mk_real (%u. EX xa. treal_eq (treal_inv xa) u & dest_real x xa))"
-  by (import hollight DEF_real_inv)
-
-definition
-  real_sub :: "hollight.real => hollight.real => hollight.real"  where
-  "real_sub == %u ua. real_add u (real_neg ua)"
-
-lemma DEF_real_sub: "real_sub = (%u ua. real_add u (real_neg ua))"
-  by (import hollight DEF_real_sub)
-
-definition
-  real_lt :: "hollight.real => hollight.real => bool"  where
-  "real_lt == %u ua. ~ real_le ua u"
-
-lemma DEF_real_lt: "real_lt = (%u ua. ~ real_le ua u)"
-  by (import hollight DEF_real_lt)
-
-definition
-  real_ge :: "hollight.real => hollight.real => bool"  where
-  "real_ge == %u ua. real_le ua u"
-
-lemma DEF_real_ge: "real_ge = (%u ua. real_le ua u)"
-  by (import hollight DEF_real_ge)
-
-definition
-  real_gt :: "hollight.real => hollight.real => bool"  where
-  "real_gt == %u ua. real_lt ua u"
-
-lemma DEF_real_gt: "real_gt = (%u ua. real_lt ua u)"
-  by (import hollight DEF_real_gt)
-
-definition
-  real_abs :: "hollight.real => hollight.real"  where
-  "real_abs == %u. if real_le (real_of_num 0) u then u else real_neg u"
-
-lemma DEF_real_abs: "real_abs = (%u. if real_le (real_of_num 0) u then u else real_neg u)"
-  by (import hollight DEF_real_abs)
-
-definition
-  real_pow :: "hollight.real => nat => hollight.real"  where
-  "real_pow ==
-SOME real_pow.
-   (ALL x. real_pow x 0 = real_of_num 1) &
-   (ALL x n. real_pow x (Suc n) = real_mul x (real_pow x n))"
-
-lemma DEF_real_pow: "real_pow =
-(SOME real_pow.
-    (ALL x. real_pow x 0 = real_of_num 1) &
-    (ALL x n. real_pow x (Suc n) = real_mul x (real_pow x n)))"
-  by (import hollight DEF_real_pow)
-
-definition
-  real_div :: "hollight.real => hollight.real => hollight.real"  where
-  "real_div == %u ua. real_mul u (real_inv ua)"
-
-lemma DEF_real_div: "real_div = (%u ua. real_mul u (real_inv ua))"
-  by (import hollight DEF_real_div)
-
-definition
-  real_max :: "hollight.real => hollight.real => hollight.real"  where
-  "real_max == %u ua. if real_le u ua then ua else u"
-
-lemma DEF_real_max: "real_max = (%u ua. if real_le u ua then ua else u)"
-  by (import hollight DEF_real_max)
-
-definition
-  real_min :: "hollight.real => hollight.real => hollight.real"  where
-  "real_min == %u ua. if real_le u ua then u else ua"
-
-lemma DEF_real_min: "real_min = (%u ua. if real_le u ua then u else ua)"
-  by (import hollight DEF_real_min)
-
-lemma REAL_HREAL_LEMMA1: "EX x. (ALL xa. real_le (real_of_num 0) xa = (EX y. xa = x y)) &
-      (ALL y z. hreal_le y z = real_le (x y) (x z))"
-  by (import hollight REAL_HREAL_LEMMA1)
-
-lemma REAL_HREAL_LEMMA2: "EX x r.
-   (ALL xa. x (r xa) = xa) &
-   (ALL xa. real_le (real_of_num 0) xa --> r (x xa) = xa) &
-   (ALL x. real_le (real_of_num 0) (r x)) &
-   (ALL x y. hreal_le x y = real_le (r x) (r y))"
-  by (import hollight REAL_HREAL_LEMMA2)
-
-lemma REAL_COMPLETE_SOMEPOS: "(EX x. P x & real_le (real_of_num 0) x) & (EX M. ALL x. P x --> real_le x M)
-==> EX M. (ALL x. P x --> real_le x M) &
-          (ALL M'. (ALL x. P x --> real_le x M') --> real_le M M')"
-  by (import hollight REAL_COMPLETE_SOMEPOS)
-
-lemma REAL_COMPLETE: "Ex P & (EX M. ALL x. P x --> real_le x M)
-==> EX M. (ALL x. P x --> real_le x M) &
-          (ALL M'. (ALL x. P x --> real_le x M') --> real_le M M')"
-  by (import hollight REAL_COMPLETE)
-
-lemma REAL_ADD_AC: "real_add m n = real_add n m &
-real_add (real_add m n) p = real_add m (real_add n p) &
-real_add m (real_add n p) = real_add n (real_add m p)"
-  by (import hollight REAL_ADD_AC)
-
-lemma REAL_ADD_RINV: "real_add x (real_neg x) = real_of_num 0"
-  by (import hollight REAL_ADD_RINV)
-
-lemma REAL_EQ_ADD_LCANCEL: "(real_add x y = real_add x z) = (y = z)"
-  by (import hollight REAL_EQ_ADD_LCANCEL)
-
-lemma REAL_EQ_ADD_RCANCEL: "(real_add x z = real_add y z) = (x = y)"
-  by (import hollight REAL_EQ_ADD_RCANCEL)
-
-lemma REAL_MUL_RZERO: "real_mul x (real_of_num 0) = real_of_num 0"
-  by (import hollight REAL_MUL_RZERO)
-
-lemma REAL_MUL_LZERO: "real_mul (real_of_num 0) x = real_of_num 0"
-  by (import hollight REAL_MUL_LZERO)
-
-lemma REAL_NEG_NEG: "real_neg (real_neg x) = x"
-  by (import hollight REAL_NEG_NEG)
-
-lemma REAL_MUL_RNEG: "real_mul x (real_neg y) = real_neg (real_mul x y)"
-  by (import hollight REAL_MUL_RNEG)
-
-lemma REAL_MUL_LNEG: "real_mul (real_neg x) y = real_neg (real_mul x y)"
-  by (import hollight REAL_MUL_LNEG)
-
-lemma REAL_NEG_ADD: "real_neg (real_add x y) = real_add (real_neg x) (real_neg y)"
-  by (import hollight REAL_NEG_ADD)
-
-lemma REAL_ADD_RID: "real_add x (real_of_num 0) = x"
-  by (import hollight REAL_ADD_RID)
-
-lemma REAL_NEG_0: "real_neg (real_of_num 0) = real_of_num 0"
-  by (import hollight REAL_NEG_0)
-
-lemma REAL_LE_LNEG: "real_le (real_neg x) y = real_le (real_of_num 0) (real_add x y)"
-  by (import hollight REAL_LE_LNEG)
-
-lemma REAL_LE_NEG2: "real_le (real_neg x) (real_neg y) = real_le y x"
-  by (import hollight REAL_LE_NEG2)
-
-lemma REAL_LE_RNEG: "real_le x (real_neg y) = real_le (real_add x y) (real_of_num 0)"
-  by (import hollight REAL_LE_RNEG)
-
-lemma REAL_OF_NUM_POW: "real_pow (real_of_num x) n = real_of_num (x ^ n)"
-  by (import hollight REAL_OF_NUM_POW)
-
-lemma REAL_POW_NEG: "real_pow (real_neg x) n =
-(if even n then real_pow x n else real_neg (real_pow x n))"
-  by (import hollight REAL_POW_NEG)
-
-lemma REAL_ABS_NUM: "real_abs (real_of_num x) = real_of_num x"
-  by (import hollight REAL_ABS_NUM)
-
-lemma REAL_ABS_NEG: "real_abs (real_neg x) = real_abs x"
-  by (import hollight REAL_ABS_NEG)
-
-lemma REAL_LTE_TOTAL: "real_lt x xa | real_le xa x"
-  by (import hollight REAL_LTE_TOTAL)
-
-lemma REAL_LET_TOTAL: "real_le x xa | real_lt xa x"
-  by (import hollight REAL_LET_TOTAL)
-
-lemma REAL_LT_IMP_LE: "real_lt x y ==> real_le x y"
-  by (import hollight REAL_LT_IMP_LE)
-
-lemma REAL_LTE_TRANS: "real_lt x y & real_le y z ==> real_lt x z"
-  by (import hollight REAL_LTE_TRANS)
-
-lemma REAL_LET_TRANS: "real_le x y & real_lt y z ==> real_lt x z"
-  by (import hollight REAL_LET_TRANS)
-
-lemma REAL_LT_TRANS: "real_lt x y & real_lt y z ==> real_lt x z"
-  by (import hollight REAL_LT_TRANS)
-
-lemma REAL_LE_ADD: "real_le (real_of_num 0) x & real_le (real_of_num 0) y
-==> real_le (real_of_num 0) (real_add x y)"
-  by (import hollight REAL_LE_ADD)
-
-lemma REAL_LTE_ANTISYM: "~ (real_lt x y & real_le y x)"
-  by (import hollight REAL_LTE_ANTISYM)
-
-lemma REAL_SUB_LE: "real_le (real_of_num 0) (real_sub x xa) = real_le xa x"
-  by (import hollight REAL_SUB_LE)
-
-lemma REAL_NEG_SUB: "real_neg (real_sub x xa) = real_sub xa x"
-  by (import hollight REAL_NEG_SUB)
-
-lemma REAL_LE_LT: "real_le x xa = (real_lt x xa | x = xa)"
-  by (import hollight REAL_LE_LT)
-
-lemma REAL_SUB_LT: "real_lt (real_of_num 0) (real_sub x xa) = real_lt xa x"
-  by (import hollight REAL_SUB_LT)
-
-lemma REAL_NOT_LT: "(~ real_lt x xa) = real_le xa x"
-  by (import hollight REAL_NOT_LT)
-
-lemma REAL_SUB_0: "(real_sub x y = real_of_num 0) = (x = y)"
-  by (import hollight REAL_SUB_0)
-
-lemma REAL_LT_LE: "real_lt x y = (real_le x y & x ~= y)"
-  by (import hollight REAL_LT_LE)
-
-lemma REAL_LT_REFL: "~ real_lt x x"
-  by (import hollight REAL_LT_REFL)
-
-lemma REAL_LTE_ADD: "real_lt (real_of_num 0) x & real_le (real_of_num 0) y
-==> real_lt (real_of_num 0) (real_add x y)"
-  by (import hollight REAL_LTE_ADD)
-
-lemma REAL_LET_ADD: "real_le (real_of_num 0) x & real_lt (real_of_num 0) y
-==> real_lt (real_of_num 0) (real_add x y)"
-  by (import hollight REAL_LET_ADD)
-
-lemma REAL_LT_ADD: "real_lt (real_of_num 0) x & real_lt (real_of_num 0) y
-==> real_lt (real_of_num 0) (real_add x y)"
-  by (import hollight REAL_LT_ADD)
-
-lemma REAL_ENTIRE: "(real_mul x y = real_of_num 0) = (x = real_of_num 0 | y = real_of_num 0)"
-  by (import hollight REAL_ENTIRE)
-
-lemma REAL_LE_NEGTOTAL: "real_le (real_of_num 0) x | real_le (real_of_num 0) (real_neg x)"
-  by (import hollight REAL_LE_NEGTOTAL)
-
-lemma REAL_LE_SQUARE: "real_le (real_of_num 0) (real_mul x x)"
-  by (import hollight REAL_LE_SQUARE)
-
-lemma REAL_MUL_RID: "real_mul x (real_of_num 1) = x"
-  by (import hollight REAL_MUL_RID)
-
-lemma REAL_POW_2: "real_pow x 2 = real_mul x x"
-  by (import hollight REAL_POW_2)
-
-lemma REAL_POLY_CLAUSES: "(ALL x y z. real_add x (real_add y z) = real_add (real_add x y) z) &
-(ALL x y. real_add x y = real_add y x) &
-(ALL x. real_add (real_of_num 0) x = x) &
-(ALL x y z. real_mul x (real_mul y z) = real_mul (real_mul x y) z) &
-(ALL x y. real_mul x y = real_mul y x) &
-(ALL x. real_mul (real_of_num 1) x = x) &
-(ALL x. real_mul (real_of_num 0) x = real_of_num 0) &
-(ALL x xa xb.
-    real_mul x (real_add xa xb) =
-    real_add (real_mul x xa) (real_mul x xb)) &
-(ALL x. real_pow x 0 = real_of_num 1) &
-(ALL x xa. real_pow x (Suc xa) = real_mul x (real_pow x xa))"
-  by (import hollight REAL_POLY_CLAUSES)
-
-lemma REAL_POLY_NEG_CLAUSES: "(ALL x. real_neg x = real_mul (real_neg (real_of_num 1)) x) &
-(ALL x xa.
-    real_sub x xa = real_add x (real_mul (real_neg (real_of_num 1)) xa))"
-  by (import hollight REAL_POLY_NEG_CLAUSES)
-
-lemma REAL_POS: "real_le (real_of_num 0) (real_of_num x)"
-  by (import hollight REAL_POS)
-
-lemma REAL_OF_NUM_LT: "real_lt (real_of_num x) (real_of_num xa) = (x < xa)"
-  by (import hollight REAL_OF_NUM_LT)
-
-lemma REAL_OF_NUM_GE: "real_ge (real_of_num x) (real_of_num xa) = (xa <= x)"
-  by (import hollight REAL_OF_NUM_GE)
-
-lemma REAL_OF_NUM_GT: "real_gt (real_of_num x) (real_of_num xa) = (xa < x)"
-  by (import hollight REAL_OF_NUM_GT)
-
-lemma REAL_OF_NUM_MAX: "real_max (real_of_num x) (real_of_num xa) = real_of_num (max x xa)"
-  by (import hollight REAL_OF_NUM_MAX)
-
-lemma REAL_OF_NUM_MIN: "real_min (real_of_num x) (real_of_num xa) = real_of_num (min x xa)"
-  by (import hollight REAL_OF_NUM_MIN)
-
-lemma REAL_OF_NUM_SUC: "real_add (real_of_num x) (real_of_num 1) = real_of_num (Suc x)"
-  by (import hollight REAL_OF_NUM_SUC)
-
-lemma REAL_OF_NUM_SUB: "m <= n ==> real_sub (real_of_num n) (real_of_num m) = real_of_num (n - m)"
-  by (import hollight REAL_OF_NUM_SUB)
-
-lemma REAL_MUL_AC: "real_mul m n = real_mul n m &
-real_mul (real_mul m n) p = real_mul m (real_mul n p) &
-real_mul m (real_mul n p) = real_mul n (real_mul m p)"
-  by (import hollight REAL_MUL_AC)
-
-lemma REAL_ADD_RDISTRIB: "real_mul (real_add x y) z = real_add (real_mul x z) (real_mul y z)"
-  by (import hollight REAL_ADD_RDISTRIB)
-
-lemma REAL_LT_LADD_IMP: "real_lt y z ==> real_lt (real_add x y) (real_add x z)"
-  by (import hollight REAL_LT_LADD_IMP)
-
-lemma REAL_LT_MUL: "real_lt (real_of_num 0) x & real_lt (real_of_num 0) y
-==> real_lt (real_of_num 0) (real_mul x y)"
-  by (import hollight REAL_LT_MUL)
-
-lemma REAL_EQ_ADD_LCANCEL_0: "(real_add x y = x) = (y = real_of_num 0)"
-  by (import hollight REAL_EQ_ADD_LCANCEL_0)
-
-lemma REAL_EQ_ADD_RCANCEL_0: "(real_add x y = y) = (x = real_of_num 0)"
-  by (import hollight REAL_EQ_ADD_RCANCEL_0)
-
-lemma REAL_LNEG_UNIQ: "(real_add x y = real_of_num 0) = (x = real_neg y)"
-  by (import hollight REAL_LNEG_UNIQ)
-
-lemma REAL_RNEG_UNIQ: "(real_add x y = real_of_num 0) = (y = real_neg x)"
-  by (import hollight REAL_RNEG_UNIQ)
-
-lemma REAL_NEG_LMUL: "real_neg (real_mul x y) = real_mul (real_neg x) y"
-  by (import hollight REAL_NEG_LMUL)
-
-lemma REAL_NEG_RMUL: "real_neg (real_mul x y) = real_mul x (real_neg y)"
-  by (import hollight REAL_NEG_RMUL)
-
-lemma REAL_NEGNEG: "real_neg (real_neg x) = x"
-  by (import hollight REAL_NEGNEG)
-
-lemma REAL_NEG_MUL2: "real_mul (real_neg x) (real_neg y) = real_mul x y"
-  by (import hollight REAL_NEG_MUL2)
-
-lemma REAL_LT_LADD: "real_lt (real_add x y) (real_add x z) = real_lt y z"
-  by (import hollight REAL_LT_LADD)
-
-lemma REAL_LT_RADD: "real_lt (real_add x z) (real_add y z) = real_lt x y"
-  by (import hollight REAL_LT_RADD)
-
-lemma REAL_LT_ANTISYM: "~ (real_lt x y & real_lt y x)"
-  by (import hollight REAL_LT_ANTISYM)
-
-lemma REAL_LT_GT: "real_lt x y ==> ~ real_lt y x"
-  by (import hollight REAL_LT_GT)
-
-lemma REAL_NOT_EQ: "(x ~= y) = (real_lt x y | real_lt y x)"
-  by (import hollight REAL_NOT_EQ)
-
-lemma REAL_LET_ANTISYM: "~ (real_le x y & real_lt y x)"
-  by (import hollight REAL_LET_ANTISYM)
-
-lemma REAL_NEG_LT0: "real_lt (real_neg x) (real_of_num 0) = real_lt (real_of_num 0) x"
-  by (import hollight REAL_NEG_LT0)
-
-lemma REAL_NEG_GT0: "real_lt (real_of_num 0) (real_neg x) = real_lt x (real_of_num 0)"
-  by (import hollight REAL_NEG_GT0)
-
-lemma REAL_NEG_LE0: "real_le (real_neg x) (real_of_num 0) = real_le (real_of_num 0) x"
-  by (import hollight REAL_NEG_LE0)
-
-lemma REAL_NEG_GE0: "real_le (real_of_num 0) (real_neg x) = real_le x (real_of_num 0)"
-  by (import hollight REAL_NEG_GE0)
-
-lemma REAL_LT_TOTAL: "x = y | real_lt x y | real_lt y x"
-  by (import hollight REAL_LT_TOTAL)
-
-lemma REAL_LT_NEGTOTAL: "x = real_of_num 0 |
-real_lt (real_of_num 0) x | real_lt (real_of_num 0) (real_neg x)"
-  by (import hollight REAL_LT_NEGTOTAL)
-
-lemma REAL_LE_01: "real_le (real_of_num 0) (real_of_num 1)"
-  by (import hollight REAL_LE_01)
-
-lemma REAL_LT_01: "real_lt (real_of_num 0) (real_of_num 1)"
-  by (import hollight REAL_LT_01)
-
-lemma REAL_LE_LADD: "real_le (real_add x y) (real_add x z) = real_le y z"
-  by (import hollight REAL_LE_LADD)
-
-lemma REAL_LE_RADD: "real_le (real_add x z) (real_add y z) = real_le x y"
-  by (import hollight REAL_LE_RADD)
-
-lemma REAL_LT_ADD2: "real_lt w x & real_lt y z ==> real_lt (real_add w y) (real_add x z)"
-  by (import hollight REAL_LT_ADD2)
-
-lemma REAL_LE_ADD2: "real_le w x & real_le y z ==> real_le (real_add w y) (real_add x z)"
-  by (import hollight REAL_LE_ADD2)
-
-lemma REAL_LT_LNEG: "real_lt (real_neg x) xa = real_lt (real_of_num 0) (real_add x xa)"
-  by (import hollight REAL_LT_LNEG)
-
-lemma REAL_LT_RNEG: "real_lt x (real_neg xa) = real_lt (real_add x xa) (real_of_num 0)"
-  by (import hollight REAL_LT_RNEG)
-
-lemma REAL_LT_ADDNEG: "real_lt y (real_add x (real_neg z)) = real_lt (real_add y z) x"
-  by (import hollight REAL_LT_ADDNEG)
-
-lemma REAL_LT_ADDNEG2: "real_lt (real_add x (real_neg y)) z = real_lt x (real_add z y)"
-  by (import hollight REAL_LT_ADDNEG2)
-
-lemma REAL_LT_ADD1: "real_le x y ==> real_lt x (real_add y (real_of_num 1))"
-  by (import hollight REAL_LT_ADD1)
-
-lemma REAL_SUB_ADD: "real_add (real_sub x y) y = x"
-  by (import hollight REAL_SUB_ADD)
-
-lemma REAL_SUB_ADD2: "real_add y (real_sub x y) = x"
-  by (import hollight REAL_SUB_ADD2)
-
-lemma REAL_SUB_REFL: "real_sub x x = real_of_num 0"
-  by (import hollight REAL_SUB_REFL)
-
-lemma REAL_LE_DOUBLE: "real_le (real_of_num 0) (real_add x x) = real_le (real_of_num 0) x"
-  by (import hollight REAL_LE_DOUBLE)
-
-lemma REAL_LE_NEGL: "real_le (real_neg x) x = real_le (real_of_num 0) x"
-  by (import hollight REAL_LE_NEGL)
-
-lemma REAL_LE_NEGR: "real_le x (real_neg x) = real_le x (real_of_num 0)"
-  by (import hollight REAL_LE_NEGR)
-
-lemma REAL_NEG_EQ_0: "(real_neg x = real_of_num 0) = (x = real_of_num 0)"
-  by (import hollight REAL_NEG_EQ_0)
-
-lemma REAL_ADD_SUB: "real_sub (real_add x y) x = y"
-  by (import hollight REAL_ADD_SUB)
-
-lemma REAL_NEG_EQ: "(real_neg x = y) = (x = real_neg y)"
-  by (import hollight REAL_NEG_EQ)
-
-lemma REAL_NEG_MINUS1: "real_neg x = real_mul (real_neg (real_of_num 1)) x"
-  by (import hollight REAL_NEG_MINUS1)
-
-lemma REAL_LT_IMP_NE: "real_lt x y ==> x ~= y"
-  by (import hollight REAL_LT_IMP_NE)
-
-lemma REAL_LE_ADDR: "real_le x (real_add x y) = real_le (real_of_num 0) y"
-  by (import hollight REAL_LE_ADDR)
-
-lemma REAL_LE_ADDL: "real_le y (real_add x y) = real_le (real_of_num 0) x"
-  by (import hollight REAL_LE_ADDL)
-
-lemma REAL_LT_ADDR: "real_lt x (real_add x y) = real_lt (real_of_num 0) y"
-  by (import hollight REAL_LT_ADDR)
-
-lemma REAL_LT_ADDL: "real_lt y (real_add x y) = real_lt (real_of_num 0) x"
-  by (import hollight REAL_LT_ADDL)
-
-lemma REAL_SUB_SUB: "real_sub (real_sub x y) x = real_neg y"
-  by (import hollight REAL_SUB_SUB)
-
-lemma REAL_LT_ADD_SUB: "real_lt (real_add x y) z = real_lt x (real_sub z y)"
-  by (import hollight REAL_LT_ADD_SUB)
-
-lemma REAL_LT_SUB_RADD: "real_lt (real_sub x y) z = real_lt x (real_add z y)"
-  by (import hollight REAL_LT_SUB_RADD)
-
-lemma REAL_LT_SUB_LADD: "real_lt x (real_sub y z) = real_lt (real_add x z) y"
-  by (import hollight REAL_LT_SUB_LADD)
-
-lemma REAL_LE_SUB_LADD: "real_le x (real_sub y z) = real_le (real_add x z) y"
-  by (import hollight REAL_LE_SUB_LADD)
-
-lemma REAL_LE_SUB_RADD: "real_le (real_sub x y) z = real_le x (real_add z y)"
-  by (import hollight REAL_LE_SUB_RADD)
-
-lemma REAL_LT_NEG: "real_lt (real_neg x) (real_neg y) = real_lt y x"
-  by (import hollight REAL_LT_NEG)
-
-lemma REAL_LE_NEG: "real_le (real_neg x) (real_neg y) = real_le y x"
-  by (import hollight REAL_LE_NEG)
-
-lemma REAL_ADD2_SUB2: "real_sub (real_add a b) (real_add c d) =
-real_add (real_sub a c) (real_sub b d)"
-  by (import hollight REAL_ADD2_SUB2)
-
-lemma REAL_SUB_LZERO: "real_sub (real_of_num 0) x = real_neg x"
-  by (import hollight REAL_SUB_LZERO)
-
-lemma REAL_SUB_RZERO: "real_sub x (real_of_num 0) = x"
-  by (import hollight REAL_SUB_RZERO)
-
-lemma REAL_LET_ADD2: "real_le w x & real_lt y z ==> real_lt (real_add w y) (real_add x z)"
-  by (import hollight REAL_LET_ADD2)
-
-lemma REAL_LTE_ADD2: "real_lt w x & real_le y z ==> real_lt (real_add w y) (real_add x z)"
-  by (import hollight REAL_LTE_ADD2)
-
-lemma REAL_SUB_LNEG: "real_sub (real_neg x) y = real_neg (real_add x y)"
-  by (import hollight REAL_SUB_LNEG)
-
-lemma REAL_SUB_RNEG: "real_sub x (real_neg y) = real_add x y"
-  by (import hollight REAL_SUB_RNEG)
-
-lemma REAL_SUB_NEG2: "real_sub (real_neg x) (real_neg y) = real_sub y x"
-  by (import hollight REAL_SUB_NEG2)
-
-lemma REAL_SUB_TRIANGLE: "real_add (real_sub a b) (real_sub b c) = real_sub a c"
-  by (import hollight REAL_SUB_TRIANGLE)
-
-lemma REAL_EQ_SUB_LADD: "(x = real_sub y z) = (real_add x z = y)"
-  by (import hollight REAL_EQ_SUB_LADD)
-
-lemma REAL_EQ_SUB_RADD: "(real_sub x y = z) = (x = real_add z y)"
-  by (import hollight REAL_EQ_SUB_RADD)
-
-lemma REAL_SUB_SUB2: "real_sub x (real_sub x y) = y"
-  by (import hollight REAL_SUB_SUB2)
-
-lemma REAL_ADD_SUB2: "real_sub x (real_add x y) = real_neg y"
-  by (import hollight REAL_ADD_SUB2)
-
-lemma REAL_EQ_IMP_LE: "x = y ==> real_le x y"
-  by (import hollight REAL_EQ_IMP_LE)
-
-lemma REAL_POS_NZ: "real_lt (real_of_num 0) x ==> x ~= real_of_num 0"
-  by (import hollight REAL_POS_NZ)
-
-lemma REAL_DIFFSQ: "real_mul (real_add x y) (real_sub x y) =
-real_sub (real_mul x x) (real_mul y y)"
-  by (import hollight REAL_DIFFSQ)
-
-lemma REAL_EQ_NEG2: "(real_neg x = real_neg y) = (x = y)"
-  by (import hollight REAL_EQ_NEG2)
-
-lemma REAL_LT_NEG2: "real_lt (real_neg x) (real_neg y) = real_lt y x"
-  by (import hollight REAL_LT_NEG2)
-
-lemma REAL_SUB_LDISTRIB: "real_mul x (real_sub y z) = real_sub (real_mul x y) (real_mul x z)"
-  by (import hollight REAL_SUB_LDISTRIB)
-
-lemma REAL_SUB_RDISTRIB: "real_mul (real_sub x y) z = real_sub (real_mul x z) (real_mul y z)"
-  by (import hollight REAL_SUB_RDISTRIB)
-
-lemma REAL_ABS_ZERO: "(real_abs x = real_of_num 0) = (x = real_of_num 0)"
-  by (import hollight REAL_ABS_ZERO)
-
-lemma REAL_ABS_0: "real_abs (real_of_num 0) = real_of_num 0"
-  by (import hollight REAL_ABS_0)
-
-lemma REAL_ABS_1: "real_abs (real_of_num 1) = real_of_num 1"
-  by (import hollight REAL_ABS_1)
-
-lemma REAL_ABS_TRIANGLE: "real_le (real_abs (real_add x y)) (real_add (real_abs x) (real_abs y))"
-  by (import hollight REAL_ABS_TRIANGLE)
-
-lemma REAL_ABS_TRIANGLE_LE: "real_le (real_add (real_abs x) (real_abs (real_sub y x))) z
-==> real_le (real_abs y) z"
-  by (import hollight REAL_ABS_TRIANGLE_LE)
-
-lemma REAL_ABS_TRIANGLE_LT: "real_lt (real_add (real_abs x) (real_abs (real_sub y x))) z
-==> real_lt (real_abs y) z"
-  by (import hollight REAL_ABS_TRIANGLE_LT)
-
-lemma REAL_ABS_POS: "real_le (real_of_num 0) (real_abs x)"
-  by (import hollight REAL_ABS_POS)
-
-lemma REAL_ABS_SUB: "real_abs (real_sub x y) = real_abs (real_sub y x)"
-  by (import hollight REAL_ABS_SUB)
-
-lemma REAL_ABS_NZ: "(x ~= real_of_num 0) = real_lt (real_of_num 0) (real_abs x)"
-  by (import hollight REAL_ABS_NZ)
-
-lemma REAL_ABS_ABS: "real_abs (real_abs x) = real_abs x"
-  by (import hollight REAL_ABS_ABS)
-
-lemma REAL_ABS_LE: "real_le x (real_abs x)"
-  by (import hollight REAL_ABS_LE)
-
-lemma REAL_ABS_REFL: "(real_abs x = x) = real_le (real_of_num 0) x"
-  by (import hollight REAL_ABS_REFL)
-
-lemma REAL_ABS_BETWEEN: "(real_lt (real_of_num 0) d &
- real_lt (real_sub x d) y & real_lt y (real_add x d)) =
-real_lt (real_abs (real_sub y x)) d"
-  by (import hollight REAL_ABS_BETWEEN)
-
-lemma REAL_ABS_BOUND: "real_lt (real_abs (real_sub x y)) d ==> real_lt y (real_add x d)"
-  by (import hollight REAL_ABS_BOUND)
-
-lemma REAL_ABS_STILLNZ: "real_lt (real_abs (real_sub x y)) (real_abs y) ==> x ~= real_of_num 0"
-  by (import hollight REAL_ABS_STILLNZ)
-
-lemma REAL_ABS_CASES: "x = real_of_num 0 | real_lt (real_of_num 0) (real_abs x)"
-  by (import hollight REAL_ABS_CASES)
-
-lemma REAL_ABS_BETWEEN1: "real_lt x z & real_lt (real_abs (real_sub y x)) (real_sub z x)
-==> real_lt y z"
-  by (import hollight REAL_ABS_BETWEEN1)
-
-lemma REAL_ABS_SIGN: "real_lt (real_abs (real_sub x y)) y ==> real_lt (real_of_num 0) x"
-  by (import hollight REAL_ABS_SIGN)
-
-lemma REAL_ABS_SIGN2: "real_lt (real_abs (real_sub x y)) (real_neg y) ==> real_lt x (real_of_num 0)"
-  by (import hollight REAL_ABS_SIGN2)
-
-lemma REAL_ABS_CIRCLE: "real_lt (real_abs h) (real_sub (real_abs y) (real_abs x))
-==> real_lt (real_abs (real_add x h)) (real_abs y)"
-  by (import hollight REAL_ABS_CIRCLE)
-
-lemma REAL_SUB_ABS: "real_le (real_sub (real_abs x) (real_abs y)) (real_abs (real_sub x y))"
-  by (import hollight REAL_SUB_ABS)
-
-lemma REAL_ABS_SUB_ABS: "real_le (real_abs (real_sub (real_abs x) (real_abs y)))
- (real_abs (real_sub x y))"
-  by (import hollight REAL_ABS_SUB_ABS)
-
-lemma REAL_ABS_BETWEEN2: "real_lt x0 y0 &
-real_lt (real_mul (real_of_num 2) (real_abs (real_sub x x0)))
- (real_sub y0 x0) &
-real_lt (real_mul (real_of_num 2) (real_abs (real_sub y y0)))
- (real_sub y0 x0)
-==> real_lt x y"
-  by (import hollight REAL_ABS_BETWEEN2)
-
-lemma REAL_ABS_BOUNDS: "real_le (real_abs x) k = (real_le (real_neg k) x & real_le x k)"
-  by (import hollight REAL_ABS_BOUNDS)
-
-lemma REAL_BOUNDS_LE: "(real_le (real_neg k) x & real_le x k) = real_le (real_abs x) k"
-  by (import hollight REAL_BOUNDS_LE)
-
-lemma REAL_BOUNDS_LT: "(real_lt (real_neg k) x & real_lt x k) = real_lt (real_abs x) k"
-  by (import hollight REAL_BOUNDS_LT)
-
-lemma REAL_MIN_MAX: "real_min x y = real_neg (real_max (real_neg x) (real_neg y))"
-  by (import hollight REAL_MIN_MAX)
-
-lemma REAL_MAX_MIN: "real_max x y = real_neg (real_min (real_neg x) (real_neg y))"
-  by (import hollight REAL_MAX_MIN)
-
-lemma REAL_MAX_MAX: "real_le x (real_max x y) & real_le y (real_max x y)"
-  by (import hollight REAL_MAX_MAX)
-
-lemma REAL_MIN_MIN: "real_le (real_min x y) x & real_le (real_min x y) y"
-  by (import hollight REAL_MIN_MIN)
-
-lemma REAL_MAX_SYM: "real_max x y = real_max y x"
-  by (import hollight REAL_MAX_SYM)
-
-lemma REAL_MIN_SYM: "real_min x y = real_min y x"
-  by (import hollight REAL_MIN_SYM)
-
-lemma REAL_LE_MAX: "real_le z (real_max x y) = (real_le z x | real_le z y)"
-  by (import hollight REAL_LE_MAX)
-
-lemma REAL_LE_MIN: "real_le z (real_min x y) = (real_le z x & real_le z y)"
-  by (import hollight REAL_LE_MIN)
-
-lemma REAL_LT_MAX: "real_lt z (real_max x y) = (real_lt z x | real_lt z y)"
-  by (import hollight REAL_LT_MAX)
-
-lemma REAL_LT_MIN: "real_lt z (real_min x y) = (real_lt z x & real_lt z y)"
-  by (import hollight REAL_LT_MIN)
-
-lemma REAL_MAX_LE: "real_le (real_max x y) z = (real_le x z & real_le y z)"
-  by (import hollight REAL_MAX_LE)
-
-lemma REAL_MIN_LE: "real_le (real_min x y) z = (real_le x z | real_le y z)"
-  by (import hollight REAL_MIN_LE)
-
-lemma REAL_MAX_LT: "real_lt (real_max x y) z = (real_lt x z & real_lt y z)"
-  by (import hollight REAL_MAX_LT)
-
-lemma REAL_MIN_LT: "real_lt (real_min x y) z = (real_lt x z | real_lt y z)"
-  by (import hollight REAL_MIN_LT)
-
-lemma REAL_MAX_ASSOC: "real_max x (real_max y z) = real_max (real_max x y) z"
-  by (import hollight REAL_MAX_ASSOC)
-
-lemma REAL_MIN_ASSOC: "real_min x (real_min y z) = real_min (real_min x y) z"
-  by (import hollight REAL_MIN_ASSOC)
-
-lemma REAL_MAX_ACI: "real_max x y = real_max y x &
-real_max (real_max x y) z = real_max x (real_max y z) &
-real_max x (real_max y z) = real_max y (real_max x z) &
-real_max x x = x & real_max x (real_max x y) = real_max x y"
-  by (import hollight REAL_MAX_ACI)
-
-lemma REAL_MIN_ACI: "real_min x y = real_min y x &
-real_min (real_min x y) z = real_min x (real_min y z) &
-real_min x (real_min y z) = real_min y (real_min x z) &
-real_min x x = x & real_min x (real_min x y) = real_min x y"
-  by (import hollight REAL_MIN_ACI)
-
-lemma REAL_ABS_MUL: "real_abs (real_mul x y) = real_mul (real_abs x) (real_abs y)"
-  by (import hollight REAL_ABS_MUL)
-
-lemma REAL_POW_LE: "real_le (real_of_num 0) x ==> real_le (real_of_num 0) (real_pow x n)"
-  by (import hollight REAL_POW_LE)
-
-lemma REAL_POW_LT: "real_lt (real_of_num 0) x ==> real_lt (real_of_num 0) (real_pow x n)"
-  by (import hollight REAL_POW_LT)
-
-lemma REAL_ABS_POW: "real_abs (real_pow x n) = real_pow (real_abs x) n"
-  by (import hollight REAL_ABS_POW)
-
-lemma REAL_LE_LMUL: "real_le (real_of_num 0) x & real_le xa xb
-==> real_le (real_mul x xa) (real_mul x xb)"
-  by (import hollight REAL_LE_LMUL)
-
-lemma REAL_LE_RMUL: "real_le x y & real_le (real_of_num 0) z
-==> real_le (real_mul x z) (real_mul y z)"
-  by (import hollight REAL_LE_RMUL)
-
-lemma REAL_LT_LMUL: "real_lt (real_of_num 0) x & real_lt xa xb
-==> real_lt (real_mul x xa) (real_mul x xb)"
-  by (import hollight REAL_LT_LMUL)
-
-lemma REAL_LT_RMUL: "real_lt x y & real_lt (real_of_num 0) z
-==> real_lt (real_mul x z) (real_mul y z)"
-  by (import hollight REAL_LT_RMUL)
-
-lemma REAL_EQ_MUL_LCANCEL: "(real_mul x y = real_mul x z) = (x = real_of_num 0 | y = z)"
-  by (import hollight REAL_EQ_MUL_LCANCEL)
-
-lemma REAL_EQ_MUL_RCANCEL: "(real_mul x xb = real_mul xa xb) = (x = xa | xb = real_of_num 0)"
-  by (import hollight REAL_EQ_MUL_RCANCEL)
-
-lemma REAL_MUL_LINV_UNIQ: "real_mul x y = real_of_num 1 ==> real_inv y = x"
-  by (import hollight REAL_MUL_LINV_UNIQ)
-
-lemma REAL_MUL_RINV_UNIQ: "real_mul x xa = real_of_num 1 ==> real_inv x = xa"
-  by (import hollight REAL_MUL_RINV_UNIQ)
-
-lemma REAL_INV_INV: "real_inv (real_inv x) = x"
-  by (import hollight REAL_INV_INV)
-
-lemma REAL_EQ_INV2: "(real_inv x = real_inv y) = (x = y)"
-  by (import hollight REAL_EQ_INV2)
-
-lemma REAL_INV_EQ_0: "(real_inv x = real_of_num 0) = (x = real_of_num 0)"
-  by (import hollight REAL_INV_EQ_0)
-
-lemma REAL_LT_INV: "real_lt (real_of_num 0) x ==> real_lt (real_of_num 0) (real_inv x)"
-  by (import hollight REAL_LT_INV)
-
-lemma REAL_LT_INV_EQ: "real_lt (real_of_num 0) (real_inv x) = real_lt (real_of_num 0) x"
-  by (import hollight REAL_LT_INV_EQ)
-
-lemma REAL_INV_NEG: "real_inv (real_neg x) = real_neg (real_inv x)"
-  by (import hollight REAL_INV_NEG)
-
-lemma REAL_LE_INV_EQ: "real_le (real_of_num 0) (real_inv x) = real_le (real_of_num 0) x"
-  by (import hollight REAL_LE_INV_EQ)
-
-lemma REAL_LE_INV: "real_le (real_of_num 0) x ==> real_le (real_of_num 0) (real_inv x)"
-  by (import hollight REAL_LE_INV)
-
-lemma REAL_MUL_RINV: "x ~= real_of_num 0 ==> real_mul x (real_inv x) = real_of_num 1"
-  by (import hollight REAL_MUL_RINV)
-
-lemma REAL_INV_1: "real_inv (real_of_num 1) = real_of_num 1"
-  by (import hollight REAL_INV_1)
-
-lemma REAL_INV_EQ_1: "(real_inv x = real_of_num 1) = (x = real_of_num 1)"
-  by (import hollight REAL_INV_EQ_1)
-
-lemma REAL_DIV_1: "real_div x (real_of_num 1) = x"
-  by (import hollight REAL_DIV_1)
-
-lemma REAL_DIV_REFL: "x ~= real_of_num 0 ==> real_div x x = real_of_num 1"
-  by (import hollight REAL_DIV_REFL)
-
-lemma REAL_DIV_RMUL: "xa ~= real_of_num 0 ==> real_mul (real_div x xa) xa = x"
-  by (import hollight REAL_DIV_RMUL)
-
-lemma REAL_DIV_LMUL: "xa ~= real_of_num 0 ==> real_mul xa (real_div x xa) = x"
-  by (import hollight REAL_DIV_LMUL)
-
-lemma REAL_ABS_INV: "real_abs (real_inv x) = real_inv (real_abs x)"
-  by (import hollight REAL_ABS_INV)
-
-lemma REAL_ABS_DIV: "real_abs (real_div x xa) = real_div (real_abs x) (real_abs xa)"
-  by (import hollight REAL_ABS_DIV)
-
-lemma REAL_INV_MUL: "real_inv (real_mul x y) = real_mul (real_inv x) (real_inv y)"
-  by (import hollight REAL_INV_MUL)
-
-lemma REAL_INV_DIV: "real_inv (real_div x xa) = real_div xa x"
-  by (import hollight REAL_INV_DIV)
-
-lemma REAL_POW_MUL: "real_pow (real_mul x y) n = real_mul (real_pow x n) (real_pow y n)"
-  by (import hollight REAL_POW_MUL)
-
-lemma REAL_POW_INV: "real_pow (real_inv x) n = real_inv (real_pow x n)"
-  by (import hollight REAL_POW_INV)
-
-lemma REAL_INV_POW: "real_inv (real_pow x xa) = real_pow (real_inv x) xa"
-  by (import hollight REAL_INV_POW)
-
-lemma REAL_POW_DIV: "real_pow (real_div x xa) xb = real_div (real_pow x xb) (real_pow xa xb)"
-  by (import hollight REAL_POW_DIV)
-
-lemma REAL_POW_ADD: "real_pow x (m + n) = real_mul (real_pow x m) (real_pow x n)"
-  by (import hollight REAL_POW_ADD)
-
-lemma REAL_POW_NZ: "x ~= real_of_num 0 ==> real_pow x n ~= real_of_num 0"
-  by (import hollight REAL_POW_NZ)
-
-lemma REAL_POW_SUB: "x ~= real_of_num 0 & m <= n
-==> real_pow x (n - m) = real_div (real_pow x n) (real_pow x m)"
-  by (import hollight REAL_POW_SUB)
-
-lemma REAL_LT_IMP_NZ: "real_lt (real_of_num 0) x ==> x ~= real_of_num 0"
-  by (import hollight REAL_LT_IMP_NZ)
-
-lemma REAL_LT_LCANCEL_IMP: "real_lt (real_of_num 0) x & real_lt (real_mul x y) (real_mul x z)
-==> real_lt y z"
-  by (import hollight REAL_LT_LCANCEL_IMP)
-
-lemma REAL_LT_RCANCEL_IMP: "real_lt (real_of_num 0) xb & real_lt (real_mul x xb) (real_mul xa xb)
-==> real_lt x xa"
-  by (import hollight REAL_LT_RCANCEL_IMP)
-
-lemma REAL_LE_LCANCEL_IMP: "real_lt (real_of_num 0) x & real_le (real_mul x y) (real_mul x z)
-==> real_le y z"
-  by (import hollight REAL_LE_LCANCEL_IMP)
-
-lemma REAL_LE_RCANCEL_IMP: "real_lt (real_of_num 0) xb & real_le (real_mul x xb) (real_mul xa xb)
-==> real_le x xa"
-  by (import hollight REAL_LE_RCANCEL_IMP)
-
-lemma REAL_LE_RMUL_EQ: "real_lt (real_of_num 0) z
-==> real_le (real_mul x z) (real_mul y z) = real_le x y"
-  by (import hollight REAL_LE_RMUL_EQ)
-
-lemma REAL_LE_LMUL_EQ: "real_lt (real_of_num 0) z
-==> real_le (real_mul z x) (real_mul z y) = real_le x y"
-  by (import hollight REAL_LE_LMUL_EQ)
-
-lemma REAL_LT_RMUL_EQ: "real_lt (real_of_num 0) xb
-==> real_lt (real_mul x xb) (real_mul xa xb) = real_lt x xa"
-  by (import hollight REAL_LT_RMUL_EQ)
-
-lemma REAL_LT_LMUL_EQ: "real_lt (real_of_num 0) xb
-==> real_lt (real_mul xb x) (real_mul xb xa) = real_lt x xa"
-  by (import hollight REAL_LT_LMUL_EQ)
-
-lemma REAL_LE_MUL_EQ: "(ALL x y.
-    real_lt (real_of_num 0) x -->
-    real_le (real_of_num 0) (real_mul x y) = real_le (real_of_num 0) y) &
-(ALL x y.
-    real_lt (real_of_num 0) y -->
-    real_le (real_of_num 0) (real_mul x y) = real_le (real_of_num 0) x)"
-  by (import hollight REAL_LE_MUL_EQ)
-
-lemma REAL_LT_MUL_EQ: "(ALL x y.
-    real_lt (real_of_num 0) x -->
-    real_lt (real_of_num 0) (real_mul x y) = real_lt (real_of_num 0) y) &
-(ALL x y.
-    real_lt (real_of_num 0) y -->
-    real_lt (real_of_num 0) (real_mul x y) = real_lt (real_of_num 0) x)"
-  by (import hollight REAL_LT_MUL_EQ)
-
-lemma REAL_MUL_POS_LT: "real_lt (real_of_num 0) (real_mul x y) =
-(real_lt (real_of_num 0) x & real_lt (real_of_num 0) y |
- real_lt x (real_of_num 0) & real_lt y (real_of_num 0))"
-  by (import hollight REAL_MUL_POS_LT)
-
-lemma REAL_MUL_POS_LE: "real_le (real_of_num 0) (real_mul x xa) =
-(x = real_of_num 0 |
- xa = real_of_num 0 |
- real_lt (real_of_num 0) x & real_lt (real_of_num 0) xa |
- real_lt x (real_of_num 0) & real_lt xa (real_of_num 0))"
-  by (import hollight REAL_MUL_POS_LE)
-
-lemma REAL_LE_RDIV_EQ: "real_lt (real_of_num 0) z
-==> real_le x (real_div y z) = real_le (real_mul x z) y"
-  by (import hollight REAL_LE_RDIV_EQ)
-
-lemma REAL_LE_LDIV_EQ: "real_lt (real_of_num 0) z
-==> real_le (real_div x z) y = real_le x (real_mul y z)"
-  by (import hollight REAL_LE_LDIV_EQ)
-
-lemma REAL_LT_RDIV_EQ: "real_lt (real_of_num 0) xb
-==> real_lt x (real_div xa xb) = real_lt (real_mul x xb) xa"
-  by (import hollight REAL_LT_RDIV_EQ)
-
-lemma REAL_LT_LDIV_EQ: "real_lt (real_of_num 0) xb
-==> real_lt (real_div x xb) xa = real_lt x (real_mul xa xb)"
-  by (import hollight REAL_LT_LDIV_EQ)
-
-lemma REAL_EQ_RDIV_EQ: "real_lt (real_of_num 0) xb ==> (x = real_div xa xb) = (real_mul x xb = xa)"
-  by (import hollight REAL_EQ_RDIV_EQ)
-
-lemma REAL_EQ_LDIV_EQ: "real_lt (real_of_num 0) xb ==> (real_div x xb = xa) = (x = real_mul xa xb)"
-  by (import hollight REAL_EQ_LDIV_EQ)
-
-lemma REAL_LT_DIV2_EQ: "real_lt (real_of_num 0) xb
-==> real_lt (real_div x xb) (real_div xa xb) = real_lt x xa"
-  by (import hollight REAL_LT_DIV2_EQ)
-
-lemma REAL_LE_DIV2_EQ: "real_lt (real_of_num 0) xb
-==> real_le (real_div x xb) (real_div xa xb) = real_le x xa"
-  by (import hollight REAL_LE_DIV2_EQ)
-
-lemma REAL_MUL_2: "real_mul (real_of_num 2) x = real_add x x"
-  by (import hollight REAL_MUL_2)
-
-lemma REAL_POW_EQ_0: "(real_pow x n = real_of_num 0) = (x = real_of_num 0 & n ~= 0)"
-  by (import hollight REAL_POW_EQ_0)
-
-lemma REAL_LE_MUL2: "real_le (real_of_num 0) w &
-real_le w x & real_le (real_of_num 0) y & real_le y z
-==> real_le (real_mul w y) (real_mul x z)"
-  by (import hollight REAL_LE_MUL2)
-
-lemma REAL_LT_MUL2: "real_le (real_of_num 0) w &
-real_lt w x & real_le (real_of_num 0) y & real_lt y z
-==> real_lt (real_mul w y) (real_mul x z)"
-  by (import hollight REAL_LT_MUL2)
-
-lemma REAL_LT_SQUARE: "real_lt (real_of_num 0) (real_mul x x) = (x ~= real_of_num 0)"
-  by (import hollight REAL_LT_SQUARE)
-
-lemma REAL_POW_1: "real_pow x 1 = x"
-  by (import hollight REAL_POW_1)
-
-lemma REAL_POW_ONE: "real_pow (real_of_num 1) n = real_of_num 1"
-  by (import hollight REAL_POW_ONE)
-
-lemma REAL_LT_INV2: "real_lt (real_of_num 0) x & real_lt x y
-==> real_lt (real_inv y) (real_inv x)"
-  by (import hollight REAL_LT_INV2)
-
-lemma REAL_LE_INV2: "real_lt (real_of_num 0) x & real_le x y
-==> real_le (real_inv y) (real_inv x)"
-  by (import hollight REAL_LE_INV2)
-
-lemma REAL_LT_LINV: "real_lt (real_of_num 0) y & real_lt (real_inv y) x
-==> real_lt (real_inv x) y"
-  by (import hollight REAL_LT_LINV)
-
-lemma REAL_LT_RINV: "real_lt (real_of_num 0) x & real_lt x (real_inv y)
-==> real_lt y (real_inv x)"
-  by (import hollight REAL_LT_RINV)
-
-lemma REAL_LE_LINV: "real_lt (real_of_num 0) y & real_le (real_inv y) x
-==> real_le (real_inv x) y"
-  by (import hollight REAL_LE_LINV)
-
-lemma REAL_LE_RINV: "real_lt (real_of_num 0) x & real_le x (real_inv y)
-==> real_le y (real_inv x)"
-  by (import hollight REAL_LE_RINV)
-
-lemma REAL_INV_LE_1: "real_le (real_of_num 1) x ==> real_le (real_inv x) (real_of_num 1)"
-  by (import hollight REAL_INV_LE_1)
-
-lemma REAL_INV_1_LE: "real_lt (real_of_num 0) x & real_le x (real_of_num 1)
-==> real_le (real_of_num 1) (real_inv x)"
-  by (import hollight REAL_INV_1_LE)
-
-lemma REAL_INV_LT_1: "real_lt (real_of_num 1) x ==> real_lt (real_inv x) (real_of_num 1)"
-  by (import hollight REAL_INV_LT_1)
-
-lemma REAL_INV_1_LT: "real_lt (real_of_num 0) x & real_lt x (real_of_num 1)
-==> real_lt (real_of_num 1) (real_inv x)"
-  by (import hollight REAL_INV_1_LT)
-
-lemma REAL_SUB_INV: "x ~= real_of_num 0 & xa ~= real_of_num 0
-==> real_sub (real_inv x) (real_inv xa) =
-    real_div (real_sub xa x) (real_mul x xa)"
-  by (import hollight REAL_SUB_INV)
-
-lemma REAL_DOWN: "real_lt (real_of_num 0) d ==> EX x. real_lt (real_of_num 0) x & real_lt x d"
-  by (import hollight REAL_DOWN)
-
-lemma REAL_DOWN2: "real_lt (real_of_num 0) d1 & real_lt (real_of_num 0) d2
-==> EX e. real_lt (real_of_num 0) e & real_lt e d1 & real_lt e d2"
-  by (import hollight REAL_DOWN2)
-
-lemma REAL_POW_LE2: "real_le (real_of_num 0) x & real_le x y
-==> real_le (real_pow x n) (real_pow y n)"
-  by (import hollight REAL_POW_LE2)
-
-lemma REAL_POW_LE_1: "real_le (real_of_num 1) x ==> real_le (real_of_num 1) (real_pow x n)"
-  by (import hollight REAL_POW_LE_1)
-
-lemma REAL_POW_1_LE: "real_le (real_of_num 0) x & real_le x (real_of_num 1)
-==> real_le (real_pow x n) (real_of_num 1)"
-  by (import hollight REAL_POW_1_LE)
-
-lemma REAL_POW_MONO: "real_le (real_of_num 1) x & m <= n ==> real_le (real_pow x m) (real_pow x n)"
-  by (import hollight REAL_POW_MONO)
-
-lemma REAL_POW_LT2: "n ~= 0 & real_le (real_of_num 0) x & real_lt x y
-==> real_lt (real_pow x n) (real_pow y n)"
-  by (import hollight REAL_POW_LT2)
-
-lemma REAL_POW_LT_1: "n ~= 0 & real_lt (real_of_num 1) x
-==> real_lt (real_of_num 1) (real_pow x n)"
-  by (import hollight REAL_POW_LT_1)
-
-lemma REAL_POW_1_LT: "n ~= 0 & real_le (real_of_num 0) x & real_lt x (real_of_num 1)
-==> real_lt (real_pow x n) (real_of_num 1)"
-  by (import hollight REAL_POW_1_LT)
-
-lemma REAL_POW_MONO_LT: "real_lt (real_of_num 1) x & m < n ==> real_lt (real_pow x m) (real_pow x n)"
-  by (import hollight REAL_POW_MONO_LT)
-
-lemma REAL_POW_POW: "real_pow (real_pow x m) n = real_pow x (m * n)"
-  by (import hollight REAL_POW_POW)
-
-lemma REAL_EQ_RCANCEL_IMP: "z ~= real_of_num 0 & real_mul x z = real_mul y z ==> x = y"
-  by (import hollight REAL_EQ_RCANCEL_IMP)
-
-lemma REAL_EQ_LCANCEL_IMP: "xb ~= real_of_num 0 & real_mul xb x = real_mul xb xa ==> x = xa"
-  by (import hollight REAL_EQ_LCANCEL_IMP)
-
-lemma REAL_LT_DIV: "real_lt (real_of_num 0) x & real_lt (real_of_num 0) xa
-==> real_lt (real_of_num 0) (real_div x xa)"
-  by (import hollight REAL_LT_DIV)
-
-lemma REAL_LE_DIV: "real_le (real_of_num 0) x & real_le (real_of_num 0) xa
-==> real_le (real_of_num 0) (real_div x xa)"
-  by (import hollight REAL_LE_DIV)
-
-lemma REAL_DIV_POW2: "x ~= real_of_num 0
-==> real_div (real_pow x m) (real_pow x n) =
-    (if n <= m then real_pow x (m - n) else real_inv (real_pow x (n - m)))"
-  by (import hollight REAL_DIV_POW2)
-
-lemma REAL_DIV_POW2_ALT: "x ~= real_of_num 0
-==> real_div (real_pow x m) (real_pow x n) =
-    (if n < m then real_pow x (m - n) else real_inv (real_pow x (n - m)))"
-  by (import hollight REAL_DIV_POW2_ALT)
-
-lemma REAL_LT_POW2: "real_lt (real_of_num 0) (real_pow (real_of_num 2) x)"
-  by (import hollight REAL_LT_POW2)
-
-lemma REAL_LE_POW2: "real_le (real_of_num 1) (real_pow (real_of_num 2) n)"
-  by (import hollight REAL_LE_POW2)
-
-lemma REAL_POW2_ABS: "real_pow (real_abs x) 2 = real_pow x 2"
-  by (import hollight REAL_POW2_ABS)
-
-lemma REAL_LE_SQUARE_ABS: "real_le (real_abs x) (real_abs y) = real_le (real_pow x 2) (real_pow y 2)"
-  by (import hollight REAL_LE_SQUARE_ABS)
-
-lemma REAL_LT_SQUARE_ABS: "real_lt (real_abs x) (real_abs xa) = real_lt (real_pow x 2) (real_pow xa 2)"
-  by (import hollight REAL_LT_SQUARE_ABS)
-
-lemma REAL_EQ_SQUARE_ABS: "(real_abs x = real_abs xa) = (real_pow x 2 = real_pow xa 2)"
-  by (import hollight REAL_EQ_SQUARE_ABS)
-
-lemma REAL_LE_POW_2: "real_le (real_of_num 0) (real_pow x 2)"
-  by (import hollight REAL_LE_POW_2)
-
-lemma REAL_SOS_EQ_0: "(real_add (real_pow x 2) (real_pow y 2) = real_of_num 0) =
-(x = real_of_num 0 & y = real_of_num 0)"
-  by (import hollight REAL_SOS_EQ_0)
-
-lemma REAL_POW_ZERO: "real_pow (real_of_num 0) n =
-(if n = 0 then real_of_num 1 else real_of_num 0)"
-  by (import hollight REAL_POW_ZERO)
-
-lemma REAL_POW_MONO_INV: "real_le (real_of_num 0) x & real_le x (real_of_num 1) & n <= m
-==> real_le (real_pow x m) (real_pow x n)"
-  by (import hollight REAL_POW_MONO_INV)
-
-lemma REAL_POW_LE2_REV: "n ~= 0 & real_le (real_of_num 0) y & real_le (real_pow x n) (real_pow y n)
-==> real_le x y"
-  by (import hollight REAL_POW_LE2_REV)
-
-lemma REAL_POW_LT2_REV: "real_le (real_of_num 0) y & real_lt (real_pow x n) (real_pow y n)
-==> real_lt x y"
-  by (import hollight REAL_POW_LT2_REV)
-
-lemma REAL_POW_EQ: "x ~= 0 &
-real_le (real_of_num 0) xa &
-real_le (real_of_num 0) xb & real_pow xa x = real_pow xb x
-==> xa = xb"
-  by (import hollight REAL_POW_EQ)
-
-lemma REAL_POW_EQ_ABS: "n ~= 0 & real_pow x n = real_pow y n ==> real_abs x = real_abs y"
-  by (import hollight REAL_POW_EQ_ABS)
-
-lemma REAL_POW_EQ_1_IMP: "n ~= 0 & real_pow x n = real_of_num 1 ==> real_abs x = real_of_num 1"
-  by (import hollight REAL_POW_EQ_1_IMP)
-
-lemma REAL_POW_EQ_1: "(real_pow x n = real_of_num 1) =
-(real_abs x = real_of_num 1 & (real_lt x (real_of_num 0) --> even n) |
- n = 0)"
-  by (import hollight REAL_POW_EQ_1)
-
-lemma REAL_POW_LT2_ODD: "real_lt x y & odd n ==> real_lt (real_pow x n) (real_pow y n)"
-  by (import hollight REAL_POW_LT2_ODD)
-
-lemma REAL_POW_LE2_ODD: "real_le xa xb & odd x ==> real_le (real_pow xa x) (real_pow xb x)"
-  by (import hollight REAL_POW_LE2_ODD)
-
-lemma REAL_POW_LT2_ODD_EQ: "odd n ==> real_lt (real_pow x n) (real_pow y n) = real_lt x y"
-  by (import hollight REAL_POW_LT2_ODD_EQ)
-
-lemma REAL_POW_LE2_ODD_EQ: "odd n ==> real_le (real_pow x n) (real_pow y n) = real_le x y"
-  by (import hollight REAL_POW_LE2_ODD_EQ)
-
-lemma REAL_POW_EQ_ODD_EQ: "odd x ==> (real_pow xa x = real_pow xb x) = (xa = xb)"
-  by (import hollight REAL_POW_EQ_ODD_EQ)
-
-lemma REAL_POW_EQ_ODD: "odd n & real_pow x n = real_pow y n ==> x = y"
-  by (import hollight REAL_POW_EQ_ODD)
-
-lemma REAL_POW_EQ_EQ: "(real_pow x n = real_pow y n) =
-(if even n then n = 0 | real_abs x = real_abs y else x = y)"
-  by (import hollight REAL_POW_EQ_EQ)
-
-definition
-  real_sgn :: "hollight.real => hollight.real"  where
-  "real_sgn ==
-%u. if real_lt (real_of_num 0) u then real_of_num 1
-    else if real_lt u (real_of_num 0) then real_neg (real_of_num 1)
-         else real_of_num 0"
-
-lemma DEF_real_sgn: "real_sgn =
-(%u. if real_lt (real_of_num 0) u then real_of_num 1
-     else if real_lt u (real_of_num 0) then real_neg (real_of_num 1)
-          else real_of_num 0)"
-  by (import hollight DEF_real_sgn)
-
-lemma REAL_SGN_0: "real_sgn (real_of_num 0) = real_of_num 0"
-  by (import hollight REAL_SGN_0)
-
-lemma REAL_SGN_NEG: "real_sgn (real_neg x) = real_neg (real_sgn x)"
-  by (import hollight REAL_SGN_NEG)
-
-lemma REAL_SGN_ABS: "real_mul (real_sgn x) (real_abs x) = x"
-  by (import hollight REAL_SGN_ABS)
-
-lemma REAL_ABS_SGN: "real_abs (real_sgn x) = real_sgn (real_abs x)"
-  by (import hollight REAL_ABS_SGN)
-
-lemma REAL_SGN: "real_sgn x = real_div x (real_abs x)"
-  by (import hollight REAL_SGN)
-
-lemma REAL_SGN_MUL: "real_sgn (real_mul x xa) = real_mul (real_sgn x) (real_sgn xa)"
-  by (import hollight REAL_SGN_MUL)
-
-lemma REAL_SGN_INV: "real_sgn (real_inv x) = real_sgn x"
-  by (import hollight REAL_SGN_INV)
-
-lemma REAL_SGN_DIV: "real_sgn (real_div x xa) = real_div (real_sgn x) (real_sgn xa)"
-  by (import hollight REAL_SGN_DIV)
-
-lemma REAL_WLOG_LE: "(ALL x y. P x y = P y x) & (ALL x y. real_le x y --> P x y) ==> P x xa"
-  by (import hollight REAL_WLOG_LE)
-
-lemma REAL_WLOG_LT: "(ALL x. P x x) & (ALL x y. P x y = P y x) & (ALL x y. real_lt x y --> P x y)
-==> P x xa"
-  by (import hollight REAL_WLOG_LT)
-
-definition
-  DECIMAL :: "nat => nat => hollight.real"  where
-  "DECIMAL == %u ua. real_div (real_of_num u) (real_of_num ua)"
-
-lemma DEF_DECIMAL: "DECIMAL = (%u ua. real_div (real_of_num u) (real_of_num ua))"
-  by (import hollight DEF_DECIMAL)
-
-lemma RAT_LEMMA1: "y1 ~= real_of_num 0 & y2 ~= real_of_num 0
-==> real_add (real_div x1 y1) (real_div x2 y2) =
-    real_mul (real_add (real_mul x1 y2) (real_mul x2 y1))
-     (real_mul (real_inv y1) (real_inv y2))"
-  by (import hollight RAT_LEMMA1)
-
-lemma RAT_LEMMA2: "real_lt (real_of_num 0) y1 & real_lt (real_of_num 0) y2
-==> real_add (real_div x1 y1) (real_div x2 y2) =
-    real_mul (real_add (real_mul x1 y2) (real_mul x2 y1))
-     (real_mul (real_inv y1) (real_inv y2))"
-  by (import hollight RAT_LEMMA2)
-
-lemma RAT_LEMMA3: "real_lt (real_of_num 0) y1 & real_lt (real_of_num 0) y2
-==> real_sub (real_div x1 y1) (real_div x2 y2) =
-    real_mul (real_sub (real_mul x1 y2) (real_mul x2 y1))
-     (real_mul (real_inv y1) (real_inv y2))"
-  by (import hollight RAT_LEMMA3)
-
-lemma RAT_LEMMA4: "real_lt (real_of_num 0) y1 & real_lt (real_of_num 0) y2
-==> real_le (real_div x1 y1) (real_div x2 y2) =
-    real_le (real_mul x1 y2) (real_mul x2 y1)"
-  by (import hollight RAT_LEMMA4)
-
-lemma RAT_LEMMA5: "real_lt (real_of_num 0) y1 & real_lt (real_of_num 0) y2
-==> (real_div x1 y1 = real_div x2 y2) = (real_mul x1 y2 = real_mul x2 y1)"
-  by (import hollight RAT_LEMMA5)
-
-lemma REAL_INTEGRAL: "(ALL x. real_mul (real_of_num 0) x = real_of_num 0) &
-(ALL x y z. (real_add x y = real_add x z) = (y = z)) &
-(ALL w x y z.
-    (real_add (real_mul w y) (real_mul x z) =
-     real_add (real_mul w z) (real_mul x y)) =
-    (w = x | y = z))"
-  by (import hollight REAL_INTEGRAL)
-
-definition
-  integer :: "hollight.real => bool"  where
-  "integer == %u. EX n. real_abs u = real_of_num n"
-
-lemma DEF_integer: "integer = (%u. EX n. real_abs u = real_of_num n)"
-  by (import hollight DEF_integer)
-
-lemma is_int: "integer x = (EX n. x = real_of_num n | x = real_neg (real_of_num n))"
-  by (import hollight is_int)
-
-typedef (open) int = "Collect integer"  morphisms "real_of_int" "int_of_real"
-  apply (rule light_ex_imp_nonempty[where t="Eps integer"])
-  by (import hollight TYDEF_int)
-
-syntax
-  real_of_int :: _ 
-
-syntax
-  int_of_real :: _ 
-
-lemmas "TYDEF_int_@intern" = typedef_hol2hollight 
-  [where a="a :: hollight.int" and r=r ,
-   OF type_definition_int]
-
-lemma dest_int_rep: "EX n. hollight.real_of_int x = real_of_num n |
-      hollight.real_of_int x = real_neg (real_of_num n)"
-  by (import hollight dest_int_rep)
-
-definition
-  int_le :: "hollight.int => hollight.int => bool"  where
-  "int_le == %u ua. real_le (hollight.real_of_int u) (hollight.real_of_int ua)"
-
-lemma DEF_int_le: "int_le = (%u ua. real_le (hollight.real_of_int u) (hollight.real_of_int ua))"
-  by (import hollight DEF_int_le)
-
-definition
-  int_lt :: "hollight.int => hollight.int => bool"  where
-  "int_lt == %u ua. real_lt (hollight.real_of_int u) (hollight.real_of_int ua)"
-
-lemma DEF_int_lt: "int_lt = (%u ua. real_lt (hollight.real_of_int u) (hollight.real_of_int ua))"
-  by (import hollight DEF_int_lt)
-
-definition
-  int_ge :: "hollight.int => hollight.int => bool"  where
-  "int_ge == %u ua. real_ge (hollight.real_of_int u) (hollight.real_of_int ua)"
-
-lemma DEF_int_ge: "int_ge = (%u ua. real_ge (hollight.real_of_int u) (hollight.real_of_int ua))"
-  by (import hollight DEF_int_ge)
-
-definition
-  int_gt :: "hollight.int => hollight.int => bool"  where
-  "int_gt == %u ua. real_gt (hollight.real_of_int u) (hollight.real_of_int ua)"
-
-lemma DEF_int_gt: "int_gt = (%u ua. real_gt (hollight.real_of_int u) (hollight.real_of_int ua))"
-  by (import hollight DEF_int_gt)
-
-definition
-  int_of_num :: "nat => hollight.int"  where
-  "int_of_num == %u. int_of_real (real_of_num u)"
-
-lemma DEF_int_of_num: "int_of_num = (%u. int_of_real (real_of_num u))"
-  by (import hollight DEF_int_of_num)
-
-lemma int_of_num_th: "hollight.real_of_int (int_of_num x) = real_of_num x"
-  by (import hollight int_of_num_th)
-
-definition
-  int_neg :: "hollight.int => hollight.int"  where
-  "int_neg == %u. int_of_real (real_neg (hollight.real_of_int u))"
-
-lemma DEF_int_neg: "int_neg = (%u. int_of_real (real_neg (hollight.real_of_int u)))"
-  by (import hollight DEF_int_neg)
-
-lemma int_neg_th: "hollight.real_of_int (int_neg x) = real_neg (hollight.real_of_int x)"
-  by (import hollight int_neg_th)
-
-definition
-  int_add :: "hollight.int => hollight.int => hollight.int"  where
-  "int_add ==
-%u ua.
-   int_of_real (real_add (hollight.real_of_int u) (hollight.real_of_int ua))"
-
-lemma DEF_int_add: "int_add =
-(%u ua.
-    int_of_real
-     (real_add (hollight.real_of_int u) (hollight.real_of_int ua)))"
-  by (import hollight DEF_int_add)
-
-lemma int_add_th: "hollight.real_of_int (int_add x xa) =
-real_add (hollight.real_of_int x) (hollight.real_of_int xa)"
-  by (import hollight int_add_th)
-
-definition
-  int_sub :: "hollight.int => hollight.int => hollight.int"  where
-  "int_sub ==
-%u ua.
-   int_of_real (real_sub (hollight.real_of_int u) (hollight.real_of_int ua))"
-
-lemma DEF_int_sub: "int_sub =
-(%u ua.
-    int_of_real
-     (real_sub (hollight.real_of_int u) (hollight.real_of_int ua)))"
-  by (import hollight DEF_int_sub)
-
-lemma int_sub_th: "hollight.real_of_int (int_sub x xa) =
-real_sub (hollight.real_of_int x) (hollight.real_of_int xa)"
-  by (import hollight int_sub_th)
-
-definition
-  int_mul :: "hollight.int => hollight.int => hollight.int"  where
-  "int_mul ==
-%u ua.
-   int_of_real (real_mul (hollight.real_of_int u) (hollight.real_of_int ua))"
-
-lemma DEF_int_mul: "int_mul =
-(%u ua.
-    int_of_real
-     (real_mul (hollight.real_of_int u) (hollight.real_of_int ua)))"
-  by (import hollight DEF_int_mul)
-
-lemma int_mul_th: "hollight.real_of_int (int_mul x y) =
-real_mul (hollight.real_of_int x) (hollight.real_of_int y)"
-  by (import hollight int_mul_th)
-
-definition
-  int_abs :: "hollight.int => hollight.int"  where
-  "int_abs == %u. int_of_real (real_abs (hollight.real_of_int u))"
-
-lemma DEF_int_abs: "int_abs = (%u. int_of_real (real_abs (hollight.real_of_int u)))"
-  by (import hollight DEF_int_abs)
-
-lemma int_abs_th: "hollight.real_of_int (int_abs x) = real_abs (hollight.real_of_int x)"
-  by (import hollight int_abs_th)
-
-definition
-  int_sgn :: "hollight.int => hollight.int"  where
-  "int_sgn == %u. int_of_real (real_sgn (hollight.real_of_int u))"
-
-lemma DEF_int_sgn: "int_sgn = (%u. int_of_real (real_sgn (hollight.real_of_int u)))"
-  by (import hollight DEF_int_sgn)
-
-lemma int_sgn_th: "hollight.real_of_int (int_sgn x) = real_sgn (hollight.real_of_int x)"
-  by (import hollight int_sgn_th)
-
-definition
-  int_max :: "hollight.int => hollight.int => hollight.int"  where
-  "int_max ==
-%u ua.
-   int_of_real (real_max (hollight.real_of_int u) (hollight.real_of_int ua))"
-
-lemma DEF_int_max: "int_max =
-(%u ua.
-    int_of_real
-     (real_max (hollight.real_of_int u) (hollight.real_of_int ua)))"
-  by (import hollight DEF_int_max)
-
-lemma int_max_th: "hollight.real_of_int (int_max x y) =
-real_max (hollight.real_of_int x) (hollight.real_of_int y)"
-  by (import hollight int_max_th)
-
-definition
-  int_min :: "hollight.int => hollight.int => hollight.int"  where
-  "int_min ==
-%u ua.
-   int_of_real (real_min (hollight.real_of_int u) (hollight.real_of_int ua))"
-
-lemma DEF_int_min: "int_min =
-(%u ua.
-    int_of_real
-     (real_min (hollight.real_of_int u) (hollight.real_of_int ua)))"
-  by (import hollight DEF_int_min)
-
-lemma int_min_th: "hollight.real_of_int (int_min x y) =
-real_min (hollight.real_of_int x) (hollight.real_of_int y)"
-  by (import hollight int_min_th)
-
-definition
-  int_pow :: "hollight.int => nat => hollight.int"  where
-  "int_pow == %u ua. int_of_real (real_pow (hollight.real_of_int u) ua)"
-
-lemma DEF_int_pow: "int_pow = (%u ua. int_of_real (real_pow (hollight.real_of_int u) ua))"
-  by (import hollight DEF_int_pow)
-
-lemma int_pow_th: "hollight.real_of_int (int_pow x xa) = real_pow (hollight.real_of_int x) xa"
-  by (import hollight int_pow_th)
-
-lemma INT_IMAGE: "(EX n. x = int_of_num n) | (EX n. x = int_neg (int_of_num n))"
-  by (import hollight INT_IMAGE)
-
-lemma INT_LT_DISCRETE: "int_lt x y = int_le (int_add x (int_of_num 1)) y"
-  by (import hollight INT_LT_DISCRETE)
-
-lemma INT_GT_DISCRETE: "int_gt x xa = int_ge x (int_add xa (int_of_num 1))"
-  by (import hollight INT_GT_DISCRETE)
-
-lemma INT_FORALL_POS: "(ALL n. P (int_of_num n)) = (ALL i. int_le (int_of_num 0) i --> P i)"
-  by (import hollight INT_FORALL_POS)
-
-lemma INT_EXISTS_POS: "(EX n. P (int_of_num n)) = (EX i. int_le (int_of_num 0) i & P i)"
-  by (import hollight INT_EXISTS_POS)
-
-lemma INT_FORALL_ABS: "(ALL n. x (int_of_num n)) = (ALL xa. x (int_abs xa))"
-  by (import hollight INT_FORALL_ABS)
-
-lemma INT_EXISTS_ABS: "(EX n. P (int_of_num n)) = (EX x. P (int_abs x))"
-  by (import hollight INT_EXISTS_ABS)
-
-lemma INT_ABS_MUL_1: "(int_abs (int_mul x y) = int_of_num 1) =
-(int_abs x = int_of_num 1 & int_abs y = int_of_num 1)"
-  by (import hollight INT_ABS_MUL_1)
-
-lemma INT_WOP: "(EX x. int_le (int_of_num 0) x & P x) =
-(EX x. int_le (int_of_num 0) x &
-       P x & (ALL y. int_le (int_of_num 0) y & P y --> int_le x y))"
-  by (import hollight INT_WOP)
-
-lemma INT_POW: "int_pow x 0 = int_of_num 1 &
-(ALL xa. int_pow x (Suc xa) = int_mul x (int_pow x xa))"
-  by (import hollight INT_POW)
-
-lemma INT_ABS: "int_abs x = (if int_le (int_of_num 0) x then x else int_neg x)"
-  by (import hollight INT_ABS)
-
-lemma INT_GE: "int_ge x xa = int_le xa x"
-  by (import hollight INT_GE)
-
-lemma INT_GT: "int_gt x xa = int_lt xa x"
-  by (import hollight INT_GT)
-
-lemma INT_LT: "int_lt x xa = (~ int_le xa x)"
-  by (import hollight INT_LT)
-
-lemma INT_ARCH: "d ~= int_of_num 0 ==> EX c. int_lt x (int_mul c d)"
-  by (import hollight INT_ARCH)
-
-lemma INT_DIVMOD_EXIST_0: "EX x xa.
-   if n = int_of_num 0 then x = int_of_num 0 & xa = m
-   else int_le (int_of_num 0) xa &
-        int_lt xa (int_abs n) & m = int_add (int_mul x n) xa"
-  by (import hollight INT_DIVMOD_EXIST_0)
-
-consts
-  div :: "hollight.int => hollight.int => hollight.int" ("div")
-
-defs
-  div_def: "div ==
-SOME q.
-   EX r. ALL m n.
-            if n = int_of_num 0 then q m n = int_of_num 0 & r m n = m
-            else int_le (int_of_num 0) (r m n) &
-                 int_lt (r m n) (int_abs n) &
-                 m = int_add (int_mul (q m n) n) (r m n)"
-
-lemma DEF_div: "div =
-(SOME q.
-    EX r. ALL m n.
-             if n = int_of_num 0 then q m n = int_of_num 0 & r m n = m
-             else int_le (int_of_num 0) (r m n) &
-                  int_lt (r m n) (int_abs n) &
-                  m = int_add (int_mul (q m n) n) (r m n))"
-  by (import hollight DEF_div)
-
-definition
-  rem :: "hollight.int => hollight.int => hollight.int"  where
-  "rem ==
-SOME r.
-   ALL m n.
-      if n = int_of_num 0 then div m n = int_of_num 0 & r m n = m
-      else int_le (int_of_num 0) (r m n) &
-           int_lt (r m n) (int_abs n) &
-           m = int_add (int_mul (div m n) n) (r m n)"
-
-lemma DEF_rem: "rem =
-(SOME r.
-    ALL m n.
-       if n = int_of_num 0 then div m n = int_of_num 0 & r m n = m
-       else int_le (int_of_num 0) (r m n) &
-            int_lt (r m n) (int_abs n) &
-            m = int_add (int_mul (div m n) n) (r m n))"
-  by (import hollight DEF_rem)
-
-lemma INT_DIVISION: "n ~= int_of_num 0
-==> m = int_add (int_mul (div m n) n) (rem m n) &
-    int_le (int_of_num 0) (rem m n) & int_lt (rem m n) (int_abs n)"
-  by (import hollight INT_DIVISION)
-
-lemma sth: "(ALL x y z. int_add x (int_add y z) = int_add (int_add x y) z) &
-(ALL x y. int_add x y = int_add y x) &
-(ALL x. int_add (int_of_num 0) x = x) &
-(ALL x y z. int_mul x (int_mul y z) = int_mul (int_mul x y) z) &
-(ALL x y. int_mul x y = int_mul y x) &
-(ALL x. int_mul (int_of_num 1) x = x) &
-(ALL x. int_mul (int_of_num 0) x = int_of_num 0) &
-(ALL x y z. int_mul x (int_add y z) = int_add (int_mul x y) (int_mul x z)) &
-(ALL x. int_pow x 0 = int_of_num 1) &
-(ALL x xa. int_pow x (Suc xa) = int_mul x (int_pow x xa))"
-  by (import hollight sth)
-
-lemma INT_INTEGRAL: "(ALL x. int_mul (int_of_num 0) x = int_of_num 0) &
-(ALL x y z. (int_add x y = int_add x z) = (y = z)) &
-(ALL w x y z.
-    (int_add (int_mul w y) (int_mul x z) =
-     int_add (int_mul w z) (int_mul x y)) =
-    (w = x | y = z))"
-  by (import hollight INT_INTEGRAL)
-
-lemma INT_DIVMOD_UNIQ: "m = int_add (int_mul q n) r & int_le (int_of_num 0) r & int_lt r (int_abs n)
-==> div m n = q & rem m n = r"
-  by (import hollight INT_DIVMOD_UNIQ)
-
-consts
-  eqeq :: "'A => 'A => ('A => 'A => bool) => bool" 
-
-defs
-  eqeq_def: "hollight.eqeq == %(u::'A) (ua::'A) ub::'A => 'A => bool. ub u ua"
-
-lemma DEF__equal__equal_: "hollight.eqeq = (%(u::'A) (ua::'A) ub::'A => 'A => bool. ub u ua)"
-  by (import hollight DEF__equal__equal_)
-
-definition
-  real_mod :: "hollight.real => hollight.real => hollight.real => bool"  where
-  "real_mod == %u ua ub. EX q. integer q & real_sub ua ub = real_mul q u"
-
-lemma DEF_real_mod: "real_mod = (%u ua ub. EX q. integer q & real_sub ua ub = real_mul q u)"
-  by (import hollight DEF_real_mod)
-
-definition
-  int_divides :: "hollight.int => hollight.int => bool"  where
-  "int_divides == %u ua. EX x. ua = int_mul u x"
-
-lemma DEF_int_divides: "int_divides = (%u ua. EX x. ua = int_mul u x)"
-  by (import hollight DEF_int_divides)
-
-consts
-  int_mod :: "hollight.int => hollight.int => hollight.int => bool" 
-
-defs
-  int_mod_def: "hollight.int_mod == %u ua ub. int_divides u (int_sub ua ub)"
-
-lemma DEF_int_mod: "hollight.int_mod = (%u ua ub. int_divides u (int_sub ua ub))"
-  by (import hollight DEF_int_mod)
-
-lemma int_congruent: "hollight.eqeq x xa (hollight.int_mod xb) =
-(EX d. int_sub x xa = int_mul xb d)"
-  by (import hollight int_congruent)
-
-consts
-  int_coprime :: "hollight.int * hollight.int => bool" 
-
-defs
-  int_coprime_def: "hollight.int_coprime ==
-%u. EX x y. int_add (int_mul (fst u) x) (int_mul (snd u) y) = int_of_num 1"
-
-lemma DEF_int_coprime: "hollight.int_coprime =
-(%u. EX x y. int_add (int_mul (fst u) x) (int_mul (snd u) y) = int_of_num 1)"
-  by (import hollight DEF_int_coprime)
-
-lemma FORALL_UNCURRY: "All (P::('A => 'B => 'C) => bool) =
-(ALL f::'A * 'B => 'C. P (%(a::'A) b::'B. f (a, b)))"
-  by (import hollight FORALL_UNCURRY)
-
-lemma EXISTS_UNCURRY: "Ex (x::('A => 'B => 'C) => bool) =
-(EX f::'A * 'B => 'C. x (%(a::'A) b::'B. f (a, b)))"
-  by (import hollight EXISTS_UNCURRY)
-
-lemma WF_INT_MEASURE: "(ALL x::'A. int_le (int_of_num (0::nat)) ((m::'A => hollight.int) x)) &
-(ALL x::'A. (ALL y::'A. int_lt (m y) (m x) --> (P::'A => bool) y) --> P x)
-==> P (x::'A)"
-  by (import hollight WF_INT_MEASURE)
-
-lemma WF_INT_MEASURE_2: "(ALL (x::'A) y::'B.
-    int_le (int_of_num (0::nat)) ((m::'A => 'B => hollight.int) x y)) &
-(ALL (x::'A) y::'B.
-    (ALL (x'::'A) y'::'B.
-        int_lt (m x' y') (m x y) --> (P::'A => 'B => bool) x' y') -->
-    P x y)
-==> P (x::'A) (xa::'B)"
-  by (import hollight WF_INT_MEASURE_2)
-
-lemma INT_GCD_EXISTS: "EX d. int_divides d a &
-      int_divides d b & (EX x y. d = int_add (int_mul a x) (int_mul b y))"
-  by (import hollight INT_GCD_EXISTS)
-
-lemma INT_GCD_EXISTS_POS: "EX d. int_le (int_of_num 0) d &
-      int_divides d a &
-      int_divides d b & (EX x y. d = int_add (int_mul a x) (int_mul b y))"
-  by (import hollight INT_GCD_EXISTS_POS)
-
-consts
-  int_gcd :: "hollight.int * hollight.int => hollight.int" 
-
-defs
-  int_gcd_def: "hollight.int_gcd ==
-SOME d.
-   ALL a b.
-      int_le (int_of_num 0) (d (a, b)) &
-      int_divides (d (a, b)) a &
-      int_divides (d (a, b)) b &
-      (EX x y. d (a, b) = int_add (int_mul a x) (int_mul b y))"
-
-lemma DEF_int_gcd: "hollight.int_gcd =
-(SOME d.
-    ALL a b.
-       int_le (int_of_num 0) (d (a, b)) &
-       int_divides (d (a, b)) a &
-       int_divides (d (a, b)) b &
-       (EX x y. d (a, b) = int_add (int_mul a x) (int_mul b y)))"
-  by (import hollight DEF_int_gcd)
-
-definition
-  num_of_int :: "hollight.int => nat"  where
-  "num_of_int == %u. SOME n. int_of_num n = u"
-
-lemma DEF_num_of_int: "num_of_int = (%u. SOME n. int_of_num n = u)"
-  by (import hollight DEF_num_of_int)
-
-lemma NUM_OF_INT_OF_NUM: "num_of_int (int_of_num x) = x"
-  by (import hollight NUM_OF_INT_OF_NUM)
-
-lemma INT_OF_NUM_OF_INT: "int_le (int_of_num 0) x ==> int_of_num (num_of_int x) = x"
-  by (import hollight INT_OF_NUM_OF_INT)
-
-lemma NUM_OF_INT: "int_le (int_of_num 0) x = (int_of_num (num_of_int x) = x)"
-  by (import hollight NUM_OF_INT)
-
-definition
-  num_divides :: "nat => nat => bool"  where
-  "num_divides == %u ua. int_divides (int_of_num u) (int_of_num ua)"
-
-lemma DEF_num_divides: "num_divides = (%u ua. int_divides (int_of_num u) (int_of_num ua))"
-  by (import hollight DEF_num_divides)
-
-definition
-  num_mod :: "nat => nat => nat => bool"  where
-  "num_mod ==
-%u ua ub. hollight.int_mod (int_of_num u) (int_of_num ua) (int_of_num ub)"
-
-lemma DEF_num_mod: "num_mod =
-(%u ua ub. hollight.int_mod (int_of_num u) (int_of_num ua) (int_of_num ub))"
-  by (import hollight DEF_num_mod)
-
-lemma num_congruent: "hollight.eqeq x xa (num_mod xb) =
-hollight.eqeq (int_of_num x) (int_of_num xa)
- (hollight.int_mod (int_of_num xb))"
-  by (import hollight num_congruent)
-
-definition
-  num_coprime :: "nat * nat => bool"  where
-  "num_coprime ==
-%u. hollight.int_coprime (int_of_num (fst u), int_of_num (snd u))"
-
-lemma DEF_num_coprime: "num_coprime =
-(%u. hollight.int_coprime (int_of_num (fst u), int_of_num (snd u)))"
-  by (import hollight DEF_num_coprime)
-
-definition
-  num_gcd :: "nat * nat => nat"  where
-  "num_gcd ==
-%u. num_of_int (hollight.int_gcd (int_of_num (fst u), int_of_num (snd u)))"
-
-lemma DEF_num_gcd: "num_gcd =
-(%u. num_of_int (hollight.int_gcd (int_of_num (fst u), int_of_num (snd u))))"
-  by (import hollight DEF_num_gcd)
-
-lemma NUM_GCD: "int_of_num (num_gcd (x, xa)) =
-hollight.int_gcd (int_of_num x, int_of_num xa)"
-  by (import hollight NUM_GCD)
-
-lemma IN_ELIM_THM: "(ALL (P::(bool => 'q_43295 => bool) => bool) x::'q_43295.
-    (x : {v::'q_43295. P (SETSPEC v)}) =
-    P (%(p::bool) t::'q_43295. p & x = t)) &
-(ALL (p::'q_43326 => bool) x::'q_43326.
-    (x : {v::'q_43326. EX y::'q_43326. p y & v = y}) = p x) &
-(ALL (P::(bool => 'q_43354 => bool) => bool) x::'q_43354.
-    x \<in> {v::'q_43354. P (SETSPEC v)} =
-    P (%(p::bool) t::'q_43354. p & x = t)) &
-(ALL (p::'q_43383 => bool) x::'q_43383.
-    x \<in> {v::'q_43383. EX y::'q_43383. p y & v = y} = p x) &
-(ALL (p::'q_43400 => bool) x::'q_43400. p x \<longleftrightarrow> p x)"
-  by (import hollight IN_ELIM_THM)
-
-lemma INSERT: "insert (x::'A) (s::'A set) = {u::'A. EX y::'A. (y : s | y = x) & u = y}"
-  by (import hollight INSERT)
-
-definition
-  SING :: "('A set) => bool"  where
-  "SING == %u::'A set. EX x::'A. u = {x}"
-
-lemma DEF_SING: "SING = (%u::'A set. EX x::'A. u = {x})"
-  by (import hollight DEF_SING)
-
-definition
-  INJ :: "('A => 'B) => ('A => bool) => ('B => bool) => bool"  where
-  "INJ ==
-%(u::'A => 'B) (ua::'A => bool) ub::'B => bool.
-   (ALL x::'A. x : ua --> u x : ub) &
-   (ALL (x::'A) y::'A. x : ua & y : ua & u x = u y --> x = y)"
-
-lemma DEF_INJ: "INJ =
-(%(u::'A => 'B) (ua::'A => bool) ub::'B => bool.
-    (ALL x::'A. x : ua --> u x : ub) &
-    (ALL (x::'A) y::'A. x : ua & y : ua & u x = u y --> x = y))"
-  by (import hollight DEF_INJ)
-
-definition
-  SURJ :: "('A => 'B) => ('A => bool) => ('B => bool) => bool"  where
-  "SURJ ==
-%(u::'A => 'B) (ua::'A => bool) ub::'B => bool.
-   (ALL x::'A. x : ua --> u x : ub) &
-   (ALL x::'B. x : ub --> (EX y::'A. y : ua & u y = x))"
-
-lemma DEF_SURJ: "SURJ =
-(%(u::'A => 'B) (ua::'A => bool) ub::'B => bool.
-    (ALL x::'A. x : ua --> u x : ub) &
-    (ALL x::'B. x : ub --> (EX y::'A. y : ua & u y = x)))"
-  by (import hollight DEF_SURJ)
-
-definition
-  BIJ :: "('A => 'B) => ('A => bool) => ('B => bool) => bool"  where
-  "BIJ ==
-%(u::'A => 'B) (ua::'A => bool) ub::'B => bool. INJ u ua ub & SURJ u ua ub"
-
-lemma DEF_BIJ: "BIJ =
-(%(u::'A => 'B) (ua::'A => bool) ub::'B => bool. INJ u ua ub & SURJ u ua ub)"
-  by (import hollight DEF_BIJ)
-
-definition
-  REST :: "('A => bool) => 'A => bool"  where
-  "REST == %u::'A => bool. u - {Eps u}"
-
-lemma DEF_REST: "REST = (%u::'A => bool. u - {Eps u})"
-  by (import hollight DEF_REST)
-
-lemma NOT_IN_EMPTY: "(x::'A) ~: {}"
-  by (import hollight NOT_IN_EMPTY)
-
-lemma IN_UNIONS: "((xa::'A) : Union (x::('A => bool) => bool)) =
-(EX t::'A => bool. t : x & xa : t)"
-  by (import hollight IN_UNIONS)
-
-lemma IN_INTERS: "((xa::'A) : Inter (x::('A => bool) => bool)) =
-(ALL t::'A => bool. t : x --> xa : t)"
-  by (import hollight IN_INTERS)
-
-lemma IN_DELETE: "((xa::'A) : (x::'A => bool) - {xb::'A}) = (xa : x & xa ~= xb)"
-  by (import hollight IN_DELETE)
-
-lemma IN_IMAGE: "((x::'B) : (xb::'A => 'B) ` (xa::'A => bool)) =
-(EX xc::'A. x = xb xc & xc : xa)"
-  by (import hollight IN_IMAGE)
-
-lemma IN_REST: "((x::'A) : REST (xa::'A => bool)) = (x : xa & x ~= Eps xa)"
-  by (import hollight IN_REST)
-
-lemma FORALL_IN_INSERT: "(ALL xc::'q_44214.
-    xc : insert (xa::'q_44214) (xb::'q_44214 => bool) -->
-    (x::'q_44214 => bool) xc) =
-(x xa & (ALL xa::'q_44214. xa : xb --> x xa))"
-  by (import hollight FORALL_IN_INSERT)
-
-lemma EXISTS_IN_INSERT: "(EX xc::'q_44255.
-    xc : insert (xa::'q_44255) (xb::'q_44255 => bool) &
-    (x::'q_44255 => bool) xc) =
-(x xa | (EX xa::'q_44255. xa : xb & x xa))"
-  by (import hollight EXISTS_IN_INSERT)
-
-lemma CHOICE_DEF: "(x::'A => bool) ~= {} ==> Eps x : x"
-  by (import hollight CHOICE_DEF)
-
-lemma NOT_EQUAL_SETS: "((x::'A => bool) ~= (xa::'A => bool)) = (EX xb::'A. (xb : xa) = (xb ~: x))"
-  by (import hollight NOT_EQUAL_SETS)
-
-lemma EMPTY_NOT_UNIV: "(op ~=::('A::type => bool) => ('A::type => bool) => bool)
- ({}::'A::type => bool) (UNIV::'A::type => bool)"
-  by (import hollight EMPTY_NOT_UNIV)
-
-lemma EQ_UNIV: "(ALL x::'A. x : (s::'A => bool)) = (s = UNIV)"
-  by (import hollight EQ_UNIV)
-
-lemma SING_SUBSET: "({xa::'q_44493} <= (x::'q_44493 => bool)) = (xa : x)"
-  by (import hollight SING_SUBSET)
-
-lemma PSUBSET_UNIV: "((x::'A => bool) < UNIV) = (EX xa::'A. xa ~: x)"
-  by (import hollight PSUBSET_UNIV)
-
-lemma PSUBSET_ALT: "((x::'A => bool) < (xa::'A => bool)) =
-(x <= xa & (EX a::'A. a : xa & a ~: x))"
-  by (import hollight PSUBSET_ALT)
-
-lemma SUBSET_UNION: "(ALL (x::'A => bool) xa::'A => bool. x <= x Un xa) &
-(ALL (x::'A => bool) xa::'A => bool. x <= xa Un x)"
-  by (import hollight SUBSET_UNION)
-
-lemma UNION_EMPTY: "(ALL x::'A => bool. {} Un x = x) & (ALL x::'A => bool. x Un {} = x)"
-  by (import hollight UNION_EMPTY)
-
-lemma UNION_UNIV: "(ALL x::'A => bool. UNIV Un x = UNIV) &
-(ALL x::'A => bool. x Un UNIV = UNIV)"
-  by (import hollight UNION_UNIV)
-
-lemma INTER_SUBSET: "(ALL (x::'A => bool) xa::'A => bool. x Int xa <= x) &
-(ALL (x::'A => bool) xa::'A => bool. xa Int x <= x)"
-  by (import hollight INTER_SUBSET)
-
-lemma INTER_EMPTY: "(ALL x::'A => bool. {} Int x = {}) & (ALL x::'A => bool. x Int {} = {})"
-  by (import hollight INTER_EMPTY)
-
-lemma INTER_UNIV: "(ALL x::'A => bool. UNIV Int x = x) & (ALL x::'A => bool. x Int UNIV = x)"
-  by (import hollight INTER_UNIV)
-
-lemma IN_DISJOINT: "((x::'A => bool) Int (xa::'A => bool) = {}) =
-(~ (EX xb::'A. xb : x & xb : xa))"
-  by (import hollight IN_DISJOINT)
-
-lemma DISJOINT_SYM: "((x::'A => bool) Int (xa::'A => bool) = {}) = (xa Int x = {})"
-  by (import hollight DISJOINT_SYM)
-
-lemma DISJOINT_EMPTY: "{} Int (x::'A => bool) = {} & x Int {} = {}"
-  by (import hollight DISJOINT_EMPTY)
-
-lemma DISJOINT_EMPTY_REFL: "((x::'A => bool) = {}) = (x Int x = {})"
-  by (import hollight DISJOINT_EMPTY_REFL)
-
-lemma DISJOINT_UNION: "(((x::'A => bool) Un (xa::'A => bool)) Int (xb::'A => bool) = {}) =
-(x Int xb = {} & xa Int xb = {})"
-  by (import hollight DISJOINT_UNION)
-
-lemma DECOMPOSITION: "((x::'A) : (s::'A => bool)) = (EX t::'A => bool. s = insert x t & x ~: t)"
-  by (import hollight DECOMPOSITION)
-
-lemma SET_CASES: "(s::'A => bool) = {} | (EX (x::'A) t::'A => bool. s = insert x t & x ~: t)"
-  by (import hollight SET_CASES)
-
-lemma ABSORPTION: "((x::'A) : (xa::'A => bool)) = (insert x xa = xa)"
-  by (import hollight ABSORPTION)
-
-lemma INSERT_UNIV: "insert (x::'A) UNIV = UNIV"
-  by (import hollight INSERT_UNIV)
-
-lemma INSERT_UNION: "insert (x::'A) (s::'A => bool) Un (t::'A => bool) =
-(if x : t then s Un t else insert x (s Un t))"
-  by (import hollight INSERT_UNION)
-
-lemma DISJOINT_INSERT: "(insert (x::'A) (xa::'A => bool) Int (xb::'A => bool) = {}) =
-(xa Int xb = {} & x ~: xb)"
-  by (import hollight DISJOINT_INSERT)
-
-lemma INSERT_AC: "insert (x::'q_45764) (insert (y::'q_45764) (s::'q_45764 => bool)) =
-insert y (insert x s) &
-insert x (insert x s) = insert x s"
-  by (import hollight INSERT_AC)
-
-lemma INTER_ACI: "(p::'q_45831 => bool) Int (q::'q_45831 => bool) = q Int p &
-p Int q Int (r::'q_45831 => bool) = p Int (q Int r) &
-p Int (q Int r) = q Int (p Int r) & p Int p = p & p Int (p Int q) = p Int q"
-  by (import hollight INTER_ACI)
-
-lemma UNION_ACI: "(p::'q_45897 => bool) Un (q::'q_45897 => bool) = q Un p &
-p Un q Un (r::'q_45897 => bool) = p Un (q Un r) &
-p Un (q Un r) = q Un (p Un r) & p Un p = p & p Un (p Un q) = p Un q"
-  by (import hollight UNION_ACI)
-
-lemma DELETE_NON_ELEMENT: "((x::'A) ~: (xa::'A => bool)) = (xa - {x} = xa)"
-  by (import hollight DELETE_NON_ELEMENT)
-
-lemma IN_DELETE_EQ: "(((x::'A) : (s::'A => bool)) = ((x'::'A) : s)) =
-((x : s - {x'}) = (x' : s - {x}))"
-  by (import hollight IN_DELETE_EQ)
-
-lemma EMPTY_DELETE: "{} - {x::'A} = {}"
-  by (import hollight EMPTY_DELETE)
-
-lemma DELETE_DELETE: "(xa::'A => bool) - {x::'A} - {x} = xa - {x}"
-  by (import hollight DELETE_DELETE)
-
-lemma DELETE_COMM: "(xb::'A => bool) - {x::'A} - {xa::'A} = xb - {xa} - {x}"
-  by (import hollight DELETE_COMM)
-
-lemma DELETE_SUBSET: "(xa::'A => bool) - {x::'A} <= xa"
-  by (import hollight DELETE_SUBSET)
-
-lemma SUBSET_DELETE: "((xa::'A => bool) <= (xb::'A => bool) - {x::'A}) = (x ~: xa & xa <= xb)"
-  by (import hollight SUBSET_DELETE)
-
-lemma SUBSET_INSERT_DELETE: "((xa::'A => bool) <= insert (x::'A) (xb::'A => bool)) = (xa - {x} <= xb)"
-  by (import hollight SUBSET_INSERT_DELETE)
-
-lemma PSUBSET_INSERT_SUBSET: "((x::'A => bool) < (xa::'A => bool)) =
-(EX xb::'A. xb ~: x & insert xb x <= xa)"
-  by (import hollight PSUBSET_INSERT_SUBSET)
-
-lemma PSUBSET_MEMBER: "((x::'A => bool) < (xa::'A => bool)) =
-(x <= xa & (EX y::'A. y : xa & y ~: x))"
-  by (import hollight PSUBSET_MEMBER)
-
-lemma DELETE_INSERT: "insert (x::'A) (s::'A => bool) - {y::'A} =
-(if x = y then s - {y} else insert x (s - {y}))"
-  by (import hollight DELETE_INSERT)
-
-lemma DELETE_INTER: "((x::'A => bool) - {xb::'A}) Int (xa::'A => bool) = x Int xa - {xb}"
-  by (import hollight DELETE_INTER)
-
-lemma DISJOINT_DELETE_SYM: "(((x::'A => bool) - {xb::'A}) Int (xa::'A => bool) = {}) =
-((xa - {xb}) Int x = {})"
-  by (import hollight DISJOINT_DELETE_SYM)
-
-lemma FORALL_IN_UNIONS: "(ALL x::'q_46386.
-    x : Union (s::('q_46386 => bool) => bool) --> (P::'q_46386 => bool) x) =
-(ALL (t::'q_46386 => bool) x::'q_46386. t : s & x : t --> P x)"
-  by (import hollight FORALL_IN_UNIONS)
-
-lemma EXISTS_IN_UNIONS: "(EX x::'q_46428.
-    x : Union (s::('q_46428 => bool) => bool) & (P::'q_46428 => bool) x) =
-(EX (t::'q_46428 => bool) x::'q_46428. t : s & x : t & P x)"
-  by (import hollight EXISTS_IN_UNIONS)
-
-lemma EMPTY_UNIONS: "(Union (x::('q_46454 => bool) => bool) = {}) =
-(ALL xa::'q_46454 => bool. xa : x --> xa = {})"
-  by (import hollight EMPTY_UNIONS)
-
-lemma INTER_UNIONS: "(ALL (x::('q_46493 => bool) => bool) xa::'q_46493 => bool.
-    Union x Int xa =
-    Union
-     {u::'q_46493 => bool.
-      EX xb::'q_46493 => bool. xb : x & u = xb Int xa}) &
-(ALL (x::('q_46529 => bool) => bool) xa::'q_46529 => bool.
-    xa Int Union x =
-    Union
-     {u::'q_46529 => bool. EX xb::'q_46529 => bool. xb : x & u = xa Int xb})"
-  by (import hollight INTER_UNIONS)
-
-lemma UNIONS_SUBSET: "(Union (x::('q_46545 => bool) => bool) <= (xa::'q_46545 => bool)) =
-(ALL xb::'q_46545 => bool. xb : x --> xb <= xa)"
-  by (import hollight UNIONS_SUBSET)
-
-lemma IMAGE_CLAUSES: "(f::'q_46676 => 'q_46680) ` {} = {} &
-f ` insert (x::'q_46676) (s::'q_46676 => bool) = insert (f x) (f ` s)"
-  by (import hollight IMAGE_CLAUSES)
-
-lemma IMAGE_INTER_INJ: "(!!(xa::'q_46846) y::'q_46846.
-    (x::'q_46846 => 'q_46857) xa = x y ==> xa = y)
-==> x ` ((xa::'q_46846 => bool) Int (xb::'q_46846 => bool)) =
-    x ` xa Int x ` xb"
-  by (import hollight IMAGE_INTER_INJ)
-
-lemma IMAGE_DIFF_INJ: "(!!(xa::'q_46900) y::'q_46900.
-    (x::'q_46900 => 'q_46911) xa = x y ==> xa = y)
-==> x ` ((xa::'q_46900 => bool) - (xb::'q_46900 => bool)) = x ` xa - x ` xb"
-  by (import hollight IMAGE_DIFF_INJ)
-
-lemma IMAGE_DELETE_INJ: "(!!xa::'q_46958.
-    (x::'q_46958 => 'q_46957) xa = x (xb::'q_46958) ==> xa = xb)
-==> x ` ((xa::'q_46958 => bool) - {xb}) = x ` xa - {x xb}"
-  by (import hollight IMAGE_DELETE_INJ)
-
-lemma FORALL_IN_IMAGE: "(ALL xb::'q_47016.
-    xb : (x::'q_47017 => 'q_47016) ` (xa::'q_47017 => bool) -->
-    (P::'q_47016 => bool) xb) =
-(ALL xb::'q_47017. xb : xa --> P (x xb))"
-  by (import hollight FORALL_IN_IMAGE)
-
-lemma EXISTS_IN_IMAGE: "(EX xb::'q_47052.
-    xb : (x::'q_47053 => 'q_47052) ` (xa::'q_47053 => bool) &
-    (P::'q_47052 => bool) xb) =
-(EX xb::'q_47053. xb : xa & P (x xb))"
-  by (import hollight EXISTS_IN_IMAGE)
-
-lemma FORALL_SUBSET_IMAGE: "(ALL xc<=(xa::'q_47140 => 'q_47156) ` (xb::'q_47140 => bool).
-    (x::('q_47156 => bool) => bool) xc) =
-(ALL t<=xb. x (xa ` t))"
-  by (import hollight FORALL_SUBSET_IMAGE)
-
-lemma EXISTS_SUBSET_IMAGE: "(EX xc<=(xa::'q_47183 => 'q_47199) ` (xb::'q_47183 => bool).
-    (x::('q_47199 => bool) => bool) xc) =
-(EX t<=xb. x (xa ` t))"
-  by (import hollight EXISTS_SUBSET_IMAGE)
-
-lemma SIMPLE_IMAGE: "{u::'q_47262.
- EX xb::'q_47258.
-    xb : (xa::'q_47258 => bool) & u = (x::'q_47258 => 'q_47262) xb} =
-x ` xa"
-  by (import hollight SIMPLE_IMAGE)
-
-lemma SIMPLE_IMAGE_GEN: "{u::'q_47292.
- EX xa::'q_47305.
-    (P::'q_47305 => bool) xa & u = (x::'q_47305 => 'q_47292) xa} =
-x ` {u::'q_47305. EX x::'q_47305. P x & u = x}"
-  by (import hollight SIMPLE_IMAGE_GEN)
-
-lemma IMAGE_UNIONS: "(x::'q_47323 => 'q_47332) ` Union (xa::('q_47323 => bool) => bool) =
-Union (op ` x ` xa)"
-  by (import hollight IMAGE_UNIONS)
-
-lemma SURJECTIVE_IMAGE_EQ: "(ALL y::'q_47396.
-    y : (xa::'q_47396 => bool) -->
-    (EX x::'q_47400. (f::'q_47400 => 'q_47396) x = y)) &
-(ALL xb::'q_47400. (f xb : xa) = (xb : (x::'q_47400 => bool)))
-==> f ` x = xa"
-  by (import hollight SURJECTIVE_IMAGE_EQ)
-
-lemma EMPTY_GSPEC: "{u::'q_47425. Ex (SETSPEC u False)} = {}"
-  by (import hollight EMPTY_GSPEC)
-
-lemma SING_GSPEC: "(ALL x::'q_47454. {u::'q_47454. EX xa::'q_47454. xa = x & u = xa} = {x}) &
-(ALL x::'q_47480. {u::'q_47480. EX xa::'q_47480. x = xa & u = xa} = {x})"
-  by (import hollight SING_GSPEC)
-
-lemma IN_ELIM_PAIR_THM: "((xa::'q_47526, xb::'q_47525)
- : {xa::'q_47526 * 'q_47525.
-    EX (xb::'q_47526) y::'q_47525.
-       (x::'q_47526 => 'q_47525 => bool) xb y & xa = (xb, y)}) =
-x xa xb"
-  by (import hollight IN_ELIM_PAIR_THM)
-
-lemma SET_PAIR_THM: "{u::'q_47570 * 'q_47569.
- EX p::'q_47570 * 'q_47569. (x::'q_47570 * 'q_47569 => bool) p & u = p} =
-{u::'q_47570 * 'q_47569.
- EX (a::'q_47570) b::'q_47569. x (a, b) & u = (a, b)}"
-  by (import hollight SET_PAIR_THM)
-
-lemma FORALL_IN_GSPEC: "(ALL (P::'q_47618 => bool) f::'q_47618 => 'q_47739.
-    (ALL z::'q_47739.
-        z : {u::'q_47739. EX x::'q_47618. P x & u = f x} -->
-        (Q::'q_47739 => bool) z) =
-    (ALL x::'q_47618. P x --> Q (f x))) &
-(ALL (P::'q_47675 => 'q_47674 => bool) f::'q_47675 => 'q_47674 => 'q_47739.
-    (ALL z::'q_47739.
-        z : {u::'q_47739.
-             EX (x::'q_47675) y::'q_47674. P x y & u = f x y} -->
-        Q z) =
-    (ALL (x::'q_47675) y::'q_47674. P x y --> Q (f x y))) &
-(ALL (P::'q_47742 => 'q_47741 => 'q_47740 => bool)
-    f::'q_47742 => 'q_47741 => 'q_47740 => 'q_47739.
-    (ALL z::'q_47739.
-        z : {u::'q_47739.
-             EX (w::'q_47742) (x::'q_47741) y::'q_47740.
-                P w x y & u = f w x y} -->
-        Q z) =
-    (ALL (w::'q_47742) (x::'q_47741) y::'q_47740. P w x y --> Q (f w x y)))"
-  by (import hollight FORALL_IN_GSPEC)
-
-lemma EXISTS_IN_GSPEC: "(ALL (P::'q_47788 => bool) f::'q_47788 => 'q_47909.
-    (EX z::'q_47909.
-        z : {u::'q_47909. EX x::'q_47788. P x & u = f x} &
-        (Q::'q_47909 => bool) z) =
-    (EX x::'q_47788. P x & Q (f x))) &
-(ALL (P::'q_47845 => 'q_47844 => bool) f::'q_47845 => 'q_47844 => 'q_47909.
-    (EX z::'q_47909.
-        z : {u::'q_47909. EX (x::'q_47845) y::'q_47844. P x y & u = f x y} &
-        Q z) =
-    (EX (x::'q_47845) y::'q_47844. P x y & Q (f x y))) &
-(ALL (P::'q_47912 => 'q_47911 => 'q_47910 => bool)
-    f::'q_47912 => 'q_47911 => 'q_47910 => 'q_47909.
-    (EX z::'q_47909.
-        z : {u::'q_47909.
-             EX (w::'q_47912) (x::'q_47911) y::'q_47910.
-                P w x y & u = f w x y} &
-        Q z) =
-    (EX (w::'q_47912) (x::'q_47911) y::'q_47910. P w x y & Q (f w x y)))"
-  by (import hollight EXISTS_IN_GSPEC)
-
-lemma SET_PROVE_CASES: "(P::('A => bool) => bool) {} &
-(ALL (a::'A) s::'A => bool. a ~: s --> P (insert a s))
-==> P (x::'A => bool)"
-  by (import hollight SET_PROVE_CASES)
-
-lemma UNIONS_IMAGE: "Union ((f::'q_47989 => 'q_47973 => bool) ` (s::'q_47989 => bool)) =
-{u::'q_47973. EX y::'q_47973. (EX x::'q_47989. x : s & y : f x) & u = y}"
-  by (import hollight UNIONS_IMAGE)
-
-lemma INTERS_IMAGE: "Inter ((f::'q_48032 => 'q_48016 => bool) ` (s::'q_48032 => bool)) =
-{u::'q_48016. EX y::'q_48016. (ALL x::'q_48032. x : s --> y : f x) & u = y}"
-  by (import hollight INTERS_IMAGE)
-
-lemma UNIONS_GSPEC: "(ALL (P::'q_48085 => bool) f::'q_48085 => 'q_48071 => bool.
-    Union {u::'q_48071 => bool. EX x::'q_48085. P x & u = f x} =
-    {u::'q_48071.
-     EX a::'q_48071. (EX x::'q_48085. P x & a : f x) & u = a}) &
-(ALL (P::'q_48149 => 'q_48148 => bool)
-    f::'q_48149 => 'q_48148 => 'q_48129 => bool.
-    Union
-     {u::'q_48129 => bool.
-      EX (x::'q_48149) y::'q_48148. P x y & u = f x y} =
-    {u::'q_48129.
-     EX a::'q_48129.
-        (EX (x::'q_48149) y::'q_48148. P x y & a : f x y) & u = a}) &
-(ALL (P::'q_48223 => 'q_48222 => 'q_48221 => bool)
-    f::'q_48223 => 'q_48222 => 'q_48221 => 'q_48197 => bool.
-    Union
-     {u::'q_48197 => bool.
-      EX (x::'q_48223) (y::'q_48222) z::'q_48221. P x y z & u = f x y z} =
-    {u::'q_48197.
-     EX a::'q_48197.
-        (EX (x::'q_48223) (y::'q_48222) z::'q_48221.
-            P x y z & a : f x y z) &
-        u = a})"
-  by (import hollight UNIONS_GSPEC)
-
-lemma INTERS_GSPEC: "(ALL (P::'q_48276 => bool) f::'q_48276 => 'q_48262 => bool.
-    Inter {u::'q_48262 => bool. EX x::'q_48276. P x & u = f x} =
-    {u::'q_48262.
-     EX a::'q_48262. (ALL x::'q_48276. P x --> a : f x) & u = a}) &
-(ALL (P::'q_48340 => 'q_48339 => bool)
-    f::'q_48340 => 'q_48339 => 'q_48320 => bool.
-    Inter
-     {u::'q_48320 => bool.
-      EX (x::'q_48340) y::'q_48339. P x y & u = f x y} =
-    {u::'q_48320.
-     EX a::'q_48320.
-        (ALL (x::'q_48340) y::'q_48339. P x y --> a : f x y) & u = a}) &
-(ALL (P::'q_48414 => 'q_48413 => 'q_48412 => bool)
-    f::'q_48414 => 'q_48413 => 'q_48412 => 'q_48388 => bool.
-    Inter
-     {u::'q_48388 => bool.
-      EX (x::'q_48414) (y::'q_48413) z::'q_48412. P x y z & u = f x y z} =
-    {u::'q_48388.
-     EX a::'q_48388.
-        (ALL (x::'q_48414) (y::'q_48413) z::'q_48412.
-            P x y z --> a : f x y z) &
-        u = a})"
-  by (import hollight INTERS_GSPEC)
-
-lemma DIFF_INTERS: "(x::'q_48451 => bool) - Inter (xa::('q_48451 => bool) => bool) =
-Union {u::'q_48451 => bool. EX xb::'q_48451 => bool. xb : xa & u = x - xb}"
-  by (import hollight DIFF_INTERS)
-
-lemma INTERS_UNIONS: "Inter (x::('q_48486 => bool) => bool) =
-UNIV -
-Union {u::'q_48486 => bool. EX t::'q_48486 => bool. t : x & u = UNIV - t}"
-  by (import hollight INTERS_UNIONS)
-
-lemma UNIONS_INTERS: "Union (s::('q_48521 => bool) => bool) =
-UNIV -
-Inter {u::'q_48521 => bool. EX t::'q_48521 => bool. t : s & u = UNIV - t}"
-  by (import hollight UNIONS_INTERS)
-
-lemma FINITE_SING: "finite {x::'q_48799}"
-  by (import hollight FINITE_SING)
-
-lemma FINITE_DELETE_IMP: "finite (s::'A => bool) ==> finite (s - {x::'A})"
-  by (import hollight FINITE_DELETE_IMP)
-
-lemma FINITE_DELETE: "finite ((s::'A => bool) - {x::'A}) = finite s"
-  by (import hollight FINITE_DELETE)
-
-lemma FINITE_FINITE_UNIONS: "finite (s::('q_48871 => bool) => bool)
-==> finite (Union s) = (ALL t::'q_48871 => bool. t : s --> finite t)"
-  by (import hollight FINITE_FINITE_UNIONS)
-
-lemma FINITE_IMAGE_EXPAND: "finite (s::'A => bool)
-==> finite
-     {u::'B. EX y::'B. (EX x::'A. x : s & y = (f::'A => 'B) x) & u = y}"
-  by (import hollight FINITE_IMAGE_EXPAND)
-
-lemma FINITE_IMAGE_INJ_GENERAL: "(ALL (x::'A) y::'A.
-    x : (s::'A => bool) & y : s & (f::'A => 'B) x = f y --> x = y) &
-finite (x::'B => bool)
-==> finite {u::'A. EX xa::'A. (xa : s & f xa : x) & u = xa}"
-  by (import hollight FINITE_IMAGE_INJ_GENERAL)
-
-lemma FINITE_FINITE_PREIMAGE_GENERAL: "finite (t::'B => bool) &
-(ALL y::'B.
-    y : t -->
-    finite
-     {u::'A. EX x::'A. (x : (s::'A => bool) & (f::'A => 'B) x = y) & u = x})
-==> finite {u::'A. EX x::'A. (x : s & f x : t) & u = x}"
-  by (import hollight FINITE_FINITE_PREIMAGE_GENERAL)
-
-lemma FINITE_FINITE_PREIMAGE: "finite (t::'B => bool) &
-(ALL y::'B. y : t --> finite {u::'A. EX x::'A. (f::'A => 'B) x = y & u = x})
-==> finite {u::'A. EX x::'A. f x : t & u = x}"
-  by (import hollight FINITE_FINITE_PREIMAGE)
-
-lemma FINITE_IMAGE_INJ_EQ: "(!!(x::'A) y::'A.
-    x : (s::'A => bool) & y : s & (f::'A => 'B) x = f y ==> x = y)
-==> finite (f ` s) = finite s"
-  by (import hollight FINITE_IMAGE_INJ_EQ)
-
-lemma FINITE_IMAGE_INJ: "(ALL (x::'A) y::'A. (f::'A => 'B) x = f y --> x = y) &
-finite (A::'B => bool)
-==> finite {u::'A. EX x::'A. f x : A & u = x}"
-  by (import hollight FINITE_IMAGE_INJ)
-
-lemma INFINITE_IMAGE_INJ: "[| !!(x::'A) y::'A. (f::'A => 'B) x = f y ==> x = y;
-   infinite (s::'A => bool) |]
-==> infinite (f ` s)"
-  by (import hollight INFINITE_IMAGE_INJ)
-
-lemma FINITE_SUBSET_IMAGE: "(finite (t::'B => bool) & t <= (f::'A => 'B) ` (s::'A => bool)) =
-(EX x::'A => bool. finite x & x <= s & t = f ` x)"
-  by (import hollight FINITE_SUBSET_IMAGE)
-
-lemma EXISTS_FINITE_SUBSET_IMAGE: "(EX xc::'q_49755 => bool.
-    finite xc &
-    xc <= (xa::'q_49735 => 'q_49755) ` (xb::'q_49735 => bool) &
-    (x::('q_49755 => bool) => bool) xc) =
-(EX xc::'q_49735 => bool. finite xc & xc <= xb & x (xa ` xc))"
-  by (import hollight EXISTS_FINITE_SUBSET_IMAGE)
-
-lemma FINITE_SUBSET_IMAGE_IMP: "finite (t::'B => bool) & t <= (f::'A => 'B) ` (s::'A => bool)
-==> EX s'::'A => bool. finite s' & s' <= s & t <= f ` s'"
-  by (import hollight FINITE_SUBSET_IMAGE_IMP)
-
-definition
-  FINREC :: "('A => 'B => 'B) => 'B => ('A => bool) => 'B => nat => bool"  where
-  "FINREC ==
-SOME FINREC::('A => 'B => 'B) => 'B => ('A => bool) => 'B => nat => bool.
-   (ALL (f::'A => 'B => 'B) (s::'A => bool) (a::'B) b::'B.
-       FINREC f b s a (0::nat) = (s = {} & a = b)) &
-   (ALL (b::'B) (s::'A => bool) (n::nat) (a::'B) f::'A => 'B => 'B.
-       FINREC f b s a (Suc n) =
-       (EX (x::'A) c::'B. x : s & FINREC f b (s - {x}) c n & a = f x c))"
-
-lemma DEF_FINREC: "FINREC =
-(SOME FINREC::('A => 'B => 'B) => 'B => ('A => bool) => 'B => nat => bool.
-    (ALL (f::'A => 'B => 'B) (s::'A => bool) (a::'B) b::'B.
-        FINREC f b s a (0::nat) = (s = {} & a = b)) &
-    (ALL (b::'B) (s::'A => bool) (n::nat) (a::'B) f::'A => 'B => 'B.
-        FINREC f b s a (Suc n) =
-        (EX (x::'A) c::'B. x : s & FINREC f b (s - {x}) c n & a = f x c)))"
-  by (import hollight DEF_FINREC)
-
-lemma FINREC_1_LEMMA: "FINREC (x::'q_49919 => 'q_49918 => 'q_49918) (xa::'q_49918)
- (xb::'q_49919 => bool) (xc::'q_49918) (Suc (0::nat)) =
-(EX xd::'q_49919. xb = {xd} & xc = x xd xa)"
-  by (import hollight FINREC_1_LEMMA)
-
-lemma FINREC_SUC_LEMMA: "[| !!(x::'A) (y::'A) s::'B.
-      x ~= y ==> (f::'A => 'B => 'B) x (f y s) = f y (f x s);
-   FINREC f (b::'B) (s::'A => bool) (z::'B) (Suc (n::nat)); (x::'A) : s |]
-==> EX w::'B. FINREC f b (s - {x}) w n & z = f x w"
-  by (import hollight FINREC_SUC_LEMMA)
-
-lemma FINREC_UNIQUE_LEMMA: "[| !!(x::'A) (y::'A) s::'B.
-      x ~= y ==> (f::'A => 'B => 'B) x (f y s) = f y (f x s);
-   FINREC f (b::'B) (s::'A => bool) (a1::'B) (n1::nat) &
-   FINREC f b s (a2::'B) (n2::nat) |]
-==> a1 = a2 & n1 = n2"
-  by (import hollight FINREC_UNIQUE_LEMMA)
-
-lemma FINREC_EXISTS_LEMMA: "finite (s::'A => bool)
-==> EX a::'B. Ex (FINREC (f::'A => 'B => 'B) (b::'B) s a)"
-  by (import hollight FINREC_EXISTS_LEMMA)
-
-lemma FINREC_FUN_LEMMA: "(ALL s::'A.
-    (P::'A => bool) s -->
-    (EX a::'B. Ex ((R::'A => 'B => 'C => bool) s a))) &
-(ALL (n1::'C) (n2::'C) (s::'A) (a1::'B) a2::'B.
-    R s a1 n1 & R s a2 n2 --> a1 = a2 & n1 = n2)
-==> EX x::'A => 'B. ALL (s::'A) a::'B. P s --> Ex (R s a) = (x s = a)"
-  by (import hollight FINREC_FUN_LEMMA)
-
-lemma FINREC_FUN: "(!!(x::'A) (y::'A) s::'B.
-    x ~= y ==> (f::'A => 'B => 'B) x (f y s) = f y (f x s))
-==> EX g::('A => bool) => 'B.
-       g {} = (b::'B) &
-       (ALL (s::'A => bool) x::'A.
-           finite s & x : s --> g s = f x (g (s - {x})))"
-  by (import hollight FINREC_FUN)
-
-lemma SET_RECURSION_LEMMA: "(!!(x::'A) (y::'A) s::'B.
-    x ~= y ==> (f::'A => 'B => 'B) x (f y s) = f y (f x s))
-==> EX g::('A => bool) => 'B.
-       g {} = (b::'B) &
-       (ALL (x::'A) s::'A => bool.
-           finite s --> g (insert x s) = (if x : s then g s else f x (g s)))"
-  by (import hollight SET_RECURSION_LEMMA)
-
-definition
-  ITSET :: "('q_50575 => 'q_50574 => 'q_50574)
-=> ('q_50575 => bool) => 'q_50574 => 'q_50574"  where
-  "ITSET ==
-%(u::'q_50575 => 'q_50574 => 'q_50574) (ua::'q_50575 => bool) ub::'q_50574.
-   (SOME g::('q_50575 => bool) => 'q_50574.
-       g {} = ub &
-       (ALL (x::'q_50575) s::'q_50575 => bool.
-           finite s -->
-           g (insert x s) = (if x : s then g s else u x (g s))))
-    ua"
-
-lemma DEF_ITSET: "ITSET =
-(%(u::'q_50575 => 'q_50574 => 'q_50574) (ua::'q_50575 => bool) ub::'q_50574.
-    (SOME g::('q_50575 => bool) => 'q_50574.
-        g {} = ub &
-        (ALL (x::'q_50575) s::'q_50575 => bool.
-            finite s -->
-            g (insert x s) = (if x : s then g s else u x (g s))))
-     ua)"
-  by (import hollight DEF_ITSET)
-
-lemma FINITE_RECURSION: "(!!(x::'A) (y::'A) s::'B.
-    x ~= y ==> (f::'A => 'B => 'B) x (f y s) = f y (f x s))
-==> ITSET f {} (b::'B) = b &
-    (ALL (x::'A) xa::'A => bool.
-        finite xa -->
-        ITSET f (insert x xa) b =
-        (if x : xa then ITSET f xa b else f x (ITSET f xa b)))"
-  by (import hollight FINITE_RECURSION)
-
-lemma FINITE_RECURSION_DELETE: "(!!(x::'A) (y::'A) s::'B.
-    x ~= y ==> (f::'A => 'B => 'B) x (f y s) = f y (f x s))
-==> ITSET f {} (b::'B) = b &
-    (ALL (x::'A) s::'A => bool.
-        finite s -->
-        ITSET f s b =
-        (if x : s then f x (ITSET f (s - {x}) b) else ITSET f (s - {x}) b))"
-  by (import hollight FINITE_RECURSION_DELETE)
-
-lemma ITSET_EQ: "finite (x::'q_50880 => bool) &
-(ALL xc::'q_50880.
-    xc : x -->
-    (xa::'q_50880 => 'q_50881 => 'q_50881) xc =
-    (xb::'q_50880 => 'q_50881 => 'q_50881) xc) &
-(ALL (x::'q_50880) (y::'q_50880) s::'q_50881.
-    x ~= y --> xa x (xa y s) = xa y (xa x s)) &
-(ALL (x::'q_50880) (y::'q_50880) s::'q_50881.
-    x ~= y --> xb x (xb y s) = xb y (xb x s))
-==> ITSET xa x (xc::'q_50881) = ITSET xb x xc"
-  by (import hollight ITSET_EQ)
-
-lemma SUBSET_RESTRICT: "{u::'q_50914.
- EX xb::'q_50914.
-    (xb : (x::'q_50914 => bool) & (xa::'q_50914 => bool) xb) & u = xb}
-<= x"
-  by (import hollight SUBSET_RESTRICT)
-
-lemma FINITE_RESTRICT: "finite (s::'A => bool)
-==> finite {u::'A. EX x::'A. (x : s & (P::'A => bool) x) & u = x}"
-  by (import hollight FINITE_RESTRICT)
-
-definition
-  CARD :: "('q_50968 => bool) => nat"  where
-  "CARD == %u::'q_50968 => bool. ITSET (%x::'q_50968. Suc) u (0::nat)"
-
-lemma DEF_CARD: "CARD = (%u::'q_50968 => bool. ITSET (%x::'q_50968. Suc) u (0::nat))"
-  by (import hollight DEF_CARD)
-
-lemma CARD_CLAUSES: "CARD {} = (0::nat) &
-(ALL (x::'A::type) s::'A::type => bool.
-    finite s -->
-    CARD (insert x s) = (if x : s then CARD s else Suc (CARD s)))"
-  by (import hollight CARD_CLAUSES)
-
-lemma CARD_UNION: "finite (x::'A => bool) & finite (xa::'A => bool) & x Int xa = {}
-==> CARD (x Un xa) = CARD x + CARD xa"
-  by (import hollight CARD_UNION)
-
-lemma CARD_DELETE: "finite (s::'A => bool)
-==> CARD (s - {x::'A}) = (if x : s then CARD s - (1::nat) else CARD s)"
-  by (import hollight CARD_DELETE)
-
-lemma CARD_UNION_EQ: "finite (u::'q_51213 => bool) &
-(s::'q_51213 => bool) Int (t::'q_51213 => bool) = {} & s Un t = u
-==> CARD s + CARD t = CARD u"
-  by (import hollight CARD_UNION_EQ)
-
-lemma CARD_DIFF: "finite (s::'q_51270 => bool) & (t::'q_51270 => bool) <= s
-==> CARD (s - t) = CARD s - CARD t"
-  by (import hollight CARD_DIFF)
-
-lemma CARD_EQ_0: "finite (s::'q_51308 => bool) ==> (CARD s = (0::nat)) = (s = {})"
-  by (import hollight CARD_EQ_0)
-
-lemma FINITE_INDUCT_DELETE: "[| (P::('A => bool) => bool) {} &
-   (ALL s::'A => bool.
-       finite s & s ~= {} --> (EX x::'A. x : s & (P (s - {x}) --> P s)));
-   finite (s::'A => bool) |]
-==> P s"
-  by (import hollight FINITE_INDUCT_DELETE)
-
-definition
-  HAS_SIZE :: "('q_51427 => bool) => nat => bool"  where
-  "HAS_SIZE == %(u::'q_51427 => bool) ua::nat. finite u & CARD u = ua"
-
-lemma DEF_HAS_SIZE: "HAS_SIZE = (%(u::'q_51427 => bool) ua::nat. finite u & CARD u = ua)"
-  by (import hollight DEF_HAS_SIZE)
-
-lemma HAS_SIZE_CARD: "HAS_SIZE (x::'q_51446 => bool) (xa::nat) ==> CARD x = xa"
-  by (import hollight HAS_SIZE_CARD)
-
-lemma HAS_SIZE_0: "HAS_SIZE (s::'A => bool) (0::nat) = (s = {})"
-  by (import hollight HAS_SIZE_0)
-
-lemma HAS_SIZE_SUC: "HAS_SIZE (s::'A => bool) (Suc (n::nat)) =
-(s ~= {} & (ALL x::'A. x : s --> HAS_SIZE (s - {x}) n))"
-  by (import hollight HAS_SIZE_SUC)
-
-lemma HAS_SIZE_UNION: "HAS_SIZE (x::'q_51584 => bool) (xb::nat) &
-HAS_SIZE (xa::'q_51584 => bool) (xc::nat) & x Int xa = {}
-==> HAS_SIZE (x Un xa) (xb + xc)"
-  by (import hollight HAS_SIZE_UNION)
-
-lemma HAS_SIZE_DIFF: "HAS_SIZE (x::'q_51620 => bool) (xb::nat) &
-HAS_SIZE (xa::'q_51620 => bool) (xc::nat) & xa <= x
-==> HAS_SIZE (x - xa) (xb - xc)"
-  by (import hollight HAS_SIZE_DIFF)
-
-lemma HAS_SIZE_UNIONS: "HAS_SIZE (x::'A => bool) (xb::nat) &
-(ALL xb::'A. xb : x --> HAS_SIZE ((xa::'A => 'B => bool) xb) (xc::nat)) &
-(ALL (xb::'A) y::'A. xb : x & y : x & xb ~= y --> xa xb Int xa y = {})
-==> HAS_SIZE (Union {u::'B => bool. EX xb::'A. xb : x & u = xa xb})
-     (xb * xc)"
-  by (import hollight HAS_SIZE_UNIONS)
-
-lemma FINITE_HAS_SIZE: "finite (x::'q_51824 => bool) = HAS_SIZE x (CARD x)"
-  by (import hollight FINITE_HAS_SIZE)
-
-lemma HAS_SIZE_CLAUSES: "HAS_SIZE (s::'q_51886 => bool) (0::nat) = (s = {}) &
-HAS_SIZE s (Suc (n::nat)) =
-(EX (a::'q_51886) t::'q_51886 => bool.
-    HAS_SIZE t n & a ~: t & s = insert a t)"
-  by (import hollight HAS_SIZE_CLAUSES)
-
-lemma CARD_SUBSET_EQ: "finite (b::'A => bool) & (a::'A => bool) <= b & CARD a = CARD b ==> a = b"
-  by (import hollight CARD_SUBSET_EQ)
-
-lemma CARD_SUBSET: "(a::'A => bool) <= (b::'A => bool) & finite b ==> CARD a <= CARD b"
-  by (import hollight CARD_SUBSET)
-
-lemma CARD_SUBSET_LE: "finite (b::'A => bool) & (a::'A => bool) <= b & CARD b <= CARD a ==> a = b"
-  by (import hollight CARD_SUBSET_LE)
-
-lemma SUBSET_CARD_EQ: "finite (t::'q_52197 => bool) & (s::'q_52197 => bool) <= t
-==> (CARD s = CARD t) = (s = t)"
-  by (import hollight SUBSET_CARD_EQ)
-
-lemma CARD_PSUBSET: "(a::'A => bool) < (b::'A => bool) & finite b ==> CARD a < CARD b"
-  by (import hollight CARD_PSUBSET)
-
-lemma CARD_UNION_LE: "finite (s::'A => bool) & finite (t::'A => bool)
-==> CARD (s Un t) <= CARD s + CARD t"
-  by (import hollight CARD_UNION_LE)
-
-lemma CARD_UNIONS_LE: "HAS_SIZE (x::'A => bool) (xb::nat) &
-(ALL xb::'A.
-    xb : x -->
-    finite ((xa::'A => 'B => bool) xb) & CARD (xa xb) <= (xc::nat))
-==> CARD (Union {u::'B => bool. EX xb::'A. xb : x & u = xa xb}) <= xb * xc"
-  by (import hollight CARD_UNIONS_LE)
-
-lemma CARD_UNION_GEN: "finite (s::'q_52620 => bool) & finite (t::'q_52620 => bool)
-==> CARD (s Un t) = CARD s + CARD t - CARD (s Int t)"
-  by (import hollight CARD_UNION_GEN)
-
-lemma CARD_UNION_OVERLAP_EQ: "finite (s::'q_52701 => bool) & finite (t::'q_52701 => bool)
-==> (CARD (s Un t) = CARD s + CARD t) = (s Int t = {})"
-  by (import hollight CARD_UNION_OVERLAP_EQ)
-
-lemma CARD_UNION_OVERLAP: "finite (x::'q_52743 => bool) &
-finite (xa::'q_52743 => bool) & CARD (x Un xa) < CARD x + CARD xa
-==> x Int xa ~= {}"
-  by (import hollight CARD_UNION_OVERLAP)
-
-lemma CARD_IMAGE_INJ: "(ALL (xa::'A) y::'A.
-    xa : (x::'A => bool) & y : x & (f::'A => 'B) xa = f y --> xa = y) &
-finite x
-==> CARD (f ` x) = CARD x"
-  by (import hollight CARD_IMAGE_INJ)
-
-lemma HAS_SIZE_IMAGE_INJ: "(ALL (xb::'A) y::'A.
-    xb : (xa::'A => bool) & y : xa & (x::'A => 'B) xb = x y --> xb = y) &
-HAS_SIZE xa (xb::nat)
-==> HAS_SIZE (x ` xa) xb"
-  by (import hollight HAS_SIZE_IMAGE_INJ)
-
-lemma CARD_IMAGE_LE: "finite (s::'A => bool) ==> CARD ((f::'A => 'B) ` s) <= CARD s"
-  by (import hollight CARD_IMAGE_LE)
-
-lemma CARD_IMAGE_INJ_EQ: "finite (s::'A => bool) &
-(ALL x::'A. x : s --> (f::'A => 'B) x : (t::'B => bool)) &
-(ALL y::'B. y : t --> (EX! x::'A. x : s & f x = y))
-==> CARD t = CARD s"
-  by (import hollight CARD_IMAGE_INJ_EQ)
-
-lemma CARD_SUBSET_IMAGE: "finite (t::'q_52977 => bool) &
-(s::'q_52984 => bool) <= (f::'q_52977 => 'q_52984) ` t
-==> CARD s <= CARD t"
-  by (import hollight CARD_SUBSET_IMAGE)
-
-lemma HAS_SIZE_IMAGE_INJ_EQ: "(!!(x::'q_53049) y::'q_53049.
-    x : (s::'q_53049 => bool) & y : s & (f::'q_53049 => 'q_53044) x = f y
-    ==> x = y)
-==> HAS_SIZE (f ` s) (n::nat) = HAS_SIZE s n"
-  by (import hollight HAS_SIZE_IMAGE_INJ_EQ)
-
-lemma CHOOSE_SUBSET_STRONG: "(finite (s::'A => bool) ==> (n::nat) <= CARD s) ==> EX t<=s. HAS_SIZE t n"
-  by (import hollight CHOOSE_SUBSET_STRONG)
-
-lemma CHOOSE_SUBSET: "[| finite (s::'A => bool); (n::nat) <= CARD s |] ==> EX t<=s. HAS_SIZE t n"
-  by (import hollight CHOOSE_SUBSET)
-
-lemma HAS_SIZE_PRODUCT_DEPENDENT: "HAS_SIZE (x::'A => bool) (xa::nat) &
-(ALL xa::'A. xa : x --> HAS_SIZE ((xb::'A => 'B => bool) xa) (xc::nat))
-==> HAS_SIZE
-     {u::'A * 'B. EX (xa::'A) y::'B. (xa : x & y : xb xa) & u = (xa, y)}
-     (xa * xc)"
-  by (import hollight HAS_SIZE_PRODUCT_DEPENDENT)
-
-lemma FINITE_PRODUCT_DEPENDENT: "finite (s::'A => bool) &
-(ALL x::'A. x : s --> finite ((t::'A => 'B => bool) x))
-==> finite
-     {u::'C.
-      EX (x::'A) y::'B. (x : s & y : t x) & u = (f::'A => 'B => 'C) x y}"
-  by (import hollight FINITE_PRODUCT_DEPENDENT)
-
-lemma FINITE_PRODUCT: "finite (x::'A => bool) & finite (xa::'B => bool)
-==> finite {u::'A * 'B. EX (xb::'A) y::'B. (xb : x & y : xa) & u = (xb, y)}"
-  by (import hollight FINITE_PRODUCT)
-
-lemma CARD_PRODUCT: "finite (s::'A => bool) & finite (t::'B => bool)
-==> CARD {u::'A * 'B. EX (x::'A) y::'B. (x : s & y : t) & u = (x, y)} =
-    CARD s * CARD t"
-  by (import hollight CARD_PRODUCT)
-
-lemma HAS_SIZE_PRODUCT: "HAS_SIZE (x::'A => bool) (xa::nat) & HAS_SIZE (xb::'B => bool) (xc::nat)
-==> HAS_SIZE
-     {u::'A * 'B. EX (xa::'A) y::'B. (xa : x & y : xb) & u = (xa, y)}
-     (xa * xc)"
-  by (import hollight HAS_SIZE_PRODUCT)
-
-definition
-  CROSS :: "('q_53759 => bool) => ('q_53758 => bool) => 'q_53759 * 'q_53758 => bool"  where
-  "CROSS ==
-%(u::'q_53759 => bool) ua::'q_53758 => bool.
-   {ub::'q_53759 * 'q_53758.
-    EX (x::'q_53759) y::'q_53758. (x : u & y : ua) & ub = (x, y)}"
-
-lemma DEF_CROSS: "CROSS =
-(%(u::'q_53759 => bool) ua::'q_53758 => bool.
-    {ub::'q_53759 * 'q_53758.
-     EX (x::'q_53759) y::'q_53758. (x : u & y : ua) & ub = (x, y)})"
-  by (import hollight DEF_CROSS)
-
-lemma IN_CROSS: "((x::'q_53795, xa::'q_53798)
- : CROSS (xb::'q_53795 => bool) (xc::'q_53798 => bool)) =
-(x : xb & xa : xc)"
-  by (import hollight IN_CROSS)
-
-lemma HAS_SIZE_CROSS: "HAS_SIZE (x::'q_53823 => bool) (xb::nat) &
-HAS_SIZE (xa::'q_53826 => bool) (xc::nat)
-==> HAS_SIZE (CROSS x xa) (xb * xc)"
-  by (import hollight HAS_SIZE_CROSS)
-
-lemma FINITE_CROSS: "finite (x::'q_53851 => bool) & finite (xa::'q_53853 => bool)
-==> finite (CROSS x xa)"
-  by (import hollight FINITE_CROSS)
-
-lemma CARD_CROSS: "finite (x::'q_53874 => bool) & finite (xa::'q_53876 => bool)
-==> CARD (CROSS x xa) = CARD x * CARD xa"
-  by (import hollight CARD_CROSS)
-
-lemma CROSS_EQ_EMPTY: "(CROSS (x::'q_53917 => bool) (xa::'q_53921 => bool) = {}) =
-(x = {} | xa = {})"
-  by (import hollight CROSS_EQ_EMPTY)
-
-lemma HAS_SIZE_FUNSPACE: "HAS_SIZE (s::'A => bool) (m::nat) & HAS_SIZE (t::'B => bool) (n::nat)
-==> HAS_SIZE
-     {u::'A => 'B.
-      EX f::'A => 'B.
-         ((ALL x::'A. x : s --> f x : t) &
-          (ALL x::'A. x ~: s --> f x = (d::'B))) &
-         u = f}
-     (n ^ m)"
-  by (import hollight HAS_SIZE_FUNSPACE)
-
-lemma CARD_FUNSPACE: "finite (s::'q_54227 => bool) & finite (t::'q_54224 => bool)
-==> CARD
-     {u::'q_54227 => 'q_54224.
-      EX f::'q_54227 => 'q_54224.
-         ((ALL x::'q_54227. x : s --> f x : t) &
-          (ALL x::'q_54227. x ~: s --> f x = (d::'q_54224))) &
-         u = f} =
-    CARD t ^ CARD s"
-  by (import hollight CARD_FUNSPACE)
-
-lemma FINITE_FUNSPACE: "finite (s::'q_54293 => bool) & finite (t::'q_54290 => bool)
-==> finite
-     {u::'q_54293 => 'q_54290.
-      EX f::'q_54293 => 'q_54290.
-         ((ALL x::'q_54293. x : s --> f x : t) &
-          (ALL x::'q_54293. x ~: s --> f x = (d::'q_54290))) &
-         u = f}"
-  by (import hollight FINITE_FUNSPACE)
-
-lemma HAS_SIZE_POWERSET: "HAS_SIZE (s::'A => bool) (n::nat)
-==> HAS_SIZE {u::'A => bool. EX t<=s. u = t} ((2::nat) ^ n)"
-  by (import hollight HAS_SIZE_POWERSET)
-
-lemma CARD_POWERSET: "finite (s::'A => bool)
-==> CARD {u::'A => bool. EX t<=s. u = t} = (2::nat) ^ CARD s"
-  by (import hollight CARD_POWERSET)
-
-lemma FINITE_POWERSET: "finite (s::'A => bool) ==> finite {u::'A => bool. EX t<=s. u = t}"
-  by (import hollight FINITE_POWERSET)
-
-lemma FINITE_UNIONS: "finite (Union (s::('A => bool) => bool)) =
-(finite s & (ALL t::'A => bool. t : s --> finite t))"
-  by (import hollight FINITE_UNIONS)
-
-lemma POWERSET_CLAUSES: "{x::'q_54515 => bool. EX xa<={}. x = xa} = {{}} &
-(ALL (x::'A) xa::'A => bool.
-    {xb::'A => bool. EX xc<=insert x xa. xb = xc} =
-    {u::'A => bool. EX s<=xa. u = s} Un
-    insert x ` {u::'A => bool. EX s<=xa. u = s})"
-  by (import hollight POWERSET_CLAUSES)
-
-lemma HAS_SIZE_NUMSEG_LT: "HAS_SIZE {u. EX m<n. u = m} n"
-  by (import hollight HAS_SIZE_NUMSEG_LT)
-
-lemma CARD_NUMSEG_LT: "CARD {u. EX m<x. u = m} = x"
-  by (import hollight CARD_NUMSEG_LT)
-
-lemma FINITE_NUMSEG_LT: "finite {u::nat. EX m<x::nat. u = m}"
-  by (import hollight FINITE_NUMSEG_LT)
-
-lemma HAS_SIZE_NUMSEG_LE: "HAS_SIZE {xa. EX xb<=x. xa = xb} (x + 1)"
-  by (import hollight HAS_SIZE_NUMSEG_LE)
-
-lemma FINITE_NUMSEG_LE: "finite {u::nat. EX m<=x::nat. u = m}"
-  by (import hollight FINITE_NUMSEG_LE)
-
-lemma CARD_NUMSEG_LE: "CARD {u. EX m<=x. u = m} = x + 1"
-  by (import hollight CARD_NUMSEG_LE)
-
-lemma num_FINITE: "finite (s::nat => bool) = (EX a::nat. ALL x::nat. x : s --> x <= a)"
-  by (import hollight num_FINITE)
-
-lemma num_FINITE_AVOID: "finite (s::nat => bool) ==> EX a::nat. a ~: s"
-  by (import hollight num_FINITE_AVOID)
-
-lemma FINITE_REAL_INTERVAL: "(ALL a. infinite {u. EX x. real_lt a x & u = x}) &
-(ALL a. infinite {u. EX x. real_le a x & u = x}) &
-(ALL b. infinite {u. EX x. real_lt x b & u = x}) &
-(ALL b. infinite {u. EX x. real_le x b & u = x}) &
-(ALL x xa.
-    finite {u. EX xb. (real_lt x xb & real_lt xb xa) & u = xb} =
-    real_le xa x) &
-(ALL a b.
-    finite {u. EX x. (real_le a x & real_lt x b) & u = x} = real_le b a) &
-(ALL a b.
-    finite {u. EX x. (real_lt a x & real_le x b) & u = x} = real_le b a) &
-(ALL a b.
-    finite {u. EX x. (real_le a x & real_le x b) & u = x} = real_le b a)"
-  by (import hollight FINITE_REAL_INTERVAL)
-
-lemma real_INFINITE: "(infinite::(hollight.real => bool) => bool) (UNIV::hollight.real => bool)"
-  by (import hollight real_INFINITE)
-
-lemma HAS_SIZE_INDEX: "HAS_SIZE (x::'A => bool) (n::nat)
-==> EX f::nat => 'A.
-       (ALL m<n. f m : x) &
-       (ALL xa::'A. xa : x --> (EX! m::nat. m < n & f m = xa))"
-  by (import hollight HAS_SIZE_INDEX)
-
-definition
-  pairwise :: "('q_55938 => 'q_55938 => bool) => ('q_55938 => bool) => bool"  where
-  "pairwise ==
-%(u::'q_55938 => 'q_55938 => bool) ua::'q_55938 => bool.
-   ALL (x::'q_55938) y::'q_55938. x : ua & y : ua & x ~= y --> u x y"
-
-lemma DEF_pairwise: "pairwise =
-(%(u::'q_55938 => 'q_55938 => bool) ua::'q_55938 => bool.
-    ALL (x::'q_55938) y::'q_55938. x : ua & y : ua & x ~= y --> u x y)"
-  by (import hollight DEF_pairwise)
-
-definition
-  PAIRWISE :: "('A => 'A => bool) => 'A list => bool"  where
-  "PAIRWISE ==
-SOME PAIRWISE::('A => 'A => bool) => 'A list => bool.
-   (ALL r::'A => 'A => bool. PAIRWISE r [] = True) &
-   (ALL (h::'A) (r::'A => 'A => bool) t::'A list.
-       PAIRWISE r (h # t) = (list_all (r h) t & PAIRWISE r t))"
-
-lemma DEF_PAIRWISE: "PAIRWISE =
-(SOME PAIRWISE::('A => 'A => bool) => 'A list => bool.
-    (ALL r::'A => 'A => bool. PAIRWISE r [] = True) &
-    (ALL (h::'A) (r::'A => 'A => bool) t::'A list.
-        PAIRWISE r (h # t) = (list_all (r h) t & PAIRWISE r t)))"
-  by (import hollight DEF_PAIRWISE)
-
-lemma PAIRWISE_EMPTY: "pairwise (x::'q_55973 => 'q_55973 => bool) {} = True"
-  by (import hollight PAIRWISE_EMPTY)
-
-lemma PAIRWISE_SING: "pairwise (x::'q_55991 => 'q_55991 => bool) {xa::'q_55991} = True"
-  by (import hollight PAIRWISE_SING)
-
-lemma PAIRWISE_MONO: "pairwise (x::'q_56011 => 'q_56011 => bool) (xa::'q_56011 => bool) &
-(xb::'q_56011 => bool) <= xa
-==> pairwise x xb"
-  by (import hollight PAIRWISE_MONO)
-
-lemma SURJECTIVE_IFF_INJECTIVE_GEN: "finite (s::'A => bool) &
-finite (t::'B => bool) & CARD s = CARD t & (f::'A => 'B) ` s <= t
-==> (ALL y::'B. y : t --> (EX x::'A. x : s & f x = y)) =
-    (ALL (x::'A) y::'A. x : s & y : s & f x = f y --> x = y)"
-  by (import hollight SURJECTIVE_IFF_INJECTIVE_GEN)
-
-lemma SURJECTIVE_IFF_INJECTIVE: "finite (x::'A => bool) & (xa::'A => 'A) ` x <= x
-==> (ALL y::'A. y : x --> (EX xb::'A. xb : x & xa xb = y)) =
-    (ALL (xb::'A) y::'A. xb : x & y : x & xa xb = xa y --> xb = y)"
-  by (import hollight SURJECTIVE_IFF_INJECTIVE)
-
-lemma IMAGE_IMP_INJECTIVE_GEN: "[| finite (s::'A => bool) &
-   CARD s = CARD (t::'B => bool) & (f::'A => 'B) ` s = t;
-   (x::'A) : s & (y::'A) : s & f x = f y |]
-==> x = y"
-  by (import hollight IMAGE_IMP_INJECTIVE_GEN)
-
-lemma IMAGE_IMP_INJECTIVE: "[| finite (s::'q_56387 => bool) & (f::'q_56387 => 'q_56387) ` s = s;
-   (x::'q_56387) : s & (y::'q_56387) : s & f x = f y |]
-==> x = y"
-  by (import hollight IMAGE_IMP_INJECTIVE)
-
-lemma CARD_LE_INJ: "finite (x::'A => bool) & finite (xa::'B => bool) & CARD x <= CARD xa
-==> EX f::'A => 'B.
-       f ` x <= xa &
-       (ALL (xa::'A) y::'A. xa : x & y : x & f xa = f y --> xa = y)"
-  by (import hollight CARD_LE_INJ)
-
-lemma FORALL_IN_CLAUSES: "(ALL x::'q_56493 => bool. (ALL xa::'q_56493. xa : {} --> x xa) = True) &
-(ALL (x::'q_56533 => bool) (xa::'q_56533) xb::'q_56533 => bool.
-    (ALL xc::'q_56533. xc : insert xa xb --> x xc) =
-    (x xa & (ALL xa::'q_56533. xa : xb --> x xa)))"
-  by (import hollight FORALL_IN_CLAUSES)
-
-lemma EXISTS_IN_CLAUSES: "(ALL x::'q_56553 => bool. (EX xa::'q_56553. xa : {} & x xa) = False) &
-(ALL (x::'q_56593 => bool) (xa::'q_56593) xb::'q_56593 => bool.
-    (EX xc::'q_56593. xc : insert xa xb & x xc) =
-    (x xa | (EX xa::'q_56593. xa : xb & x xa)))"
-  by (import hollight EXISTS_IN_CLAUSES)
-
-lemma SURJECTIVE_ON_RIGHT_INVERSE: "(ALL xb::'q_56650.
-    xb : (xa::'q_56650 => bool) -->
-    (EX xa::'q_56649.
-        xa : (s::'q_56649 => bool) & (x::'q_56649 => 'q_56650) xa = xb)) =
-(EX g::'q_56650 => 'q_56649.
-    ALL y::'q_56650. y : xa --> g y : s & x (g y) = y)"
-  by (import hollight SURJECTIVE_ON_RIGHT_INVERSE)
-
-lemma INJECTIVE_ON_LEFT_INVERSE: "(ALL (xb::'q_56743) y::'q_56743.
-    xb : (xa::'q_56743 => bool) &
-    y : xa & (x::'q_56743 => 'q_56746) xb = x y -->
-    xb = y) =
-(EX xb::'q_56746 => 'q_56743. ALL xc::'q_56743. xc : xa --> xb (x xc) = xc)"
-  by (import hollight INJECTIVE_ON_LEFT_INVERSE)
-
-lemma BIJECTIVE_ON_LEFT_RIGHT_INVERSE: "(!!x::'q_56878.
-    x : (s::'q_56878 => bool)
-    ==> (f::'q_56878 => 'q_56877) x : (t::'q_56877 => bool))
-==> ((ALL (x::'q_56878) y::'q_56878. x : s & y : s & f x = f y --> x = y) &
-     (ALL x::'q_56877. x : t --> (EX xa::'q_56878. xa : s & f xa = x))) =
-    (EX g::'q_56877 => 'q_56878.
-        (ALL y::'q_56877. y : t --> g y : s) &
-        (ALL y::'q_56877. y : t --> f (g y) = y) &
-        (ALL x::'q_56878. x : s --> g (f x) = x))"
-  by (import hollight BIJECTIVE_ON_LEFT_RIGHT_INVERSE)
-
-lemma SURJECTIVE_RIGHT_INVERSE: "(ALL y::'q_56902. EX x::'q_56905. (f::'q_56905 => 'q_56902) x = y) =
-(EX g::'q_56902 => 'q_56905. ALL y::'q_56902. f (g y) = y)"
-  by (import hollight SURJECTIVE_RIGHT_INVERSE)
-
-lemma INJECTIVE_LEFT_INVERSE: "(ALL (x::'q_56939) xa::'q_56939.
-    (f::'q_56939 => 'q_56942) x = f xa --> x = xa) =
-(EX g::'q_56942 => 'q_56939. ALL x::'q_56939. g (f x) = x)"
-  by (import hollight INJECTIVE_LEFT_INVERSE)
-
-lemma BIJECTIVE_LEFT_RIGHT_INVERSE: "((ALL (x::'A) y::'A. (f::'A => 'B) x = f y --> x = y) &
- (ALL y::'B. EX x::'A. f x = y)) =
-(EX g::'B => 'A. (ALL y::'B. f (g y) = y) & (ALL x::'A. g (f x) = x))"
-  by (import hollight BIJECTIVE_LEFT_RIGHT_INVERSE)
-
-lemma FUNCTION_FACTORS_RIGHT: "(ALL xb::'q_57046.
-    EX y::'q_57034.
-       (xa::'q_57034 => 'q_57047) y = (x::'q_57046 => 'q_57047) xb) =
-(EX xb::'q_57046 => 'q_57034. x = xa o xb)"
-  by (import hollight FUNCTION_FACTORS_RIGHT)
-
-lemma FUNCTION_FACTORS_LEFT: "(ALL (xb::'q_57119) y::'q_57119.
-    (xa::'q_57119 => 'q_57099) xb = xa y -->
-    (x::'q_57119 => 'q_57120) xb = x y) =
-(EX xb::'q_57099 => 'q_57120. x = xb o xa)"
-  by (import hollight FUNCTION_FACTORS_LEFT)
-
-lemma SURJECTIVE_FORALL_THM: "(ALL y::'B. EX x::'A. (f::'A => 'B) x = y) =
-(ALL P::'B => bool. (ALL x::'A. P (f x)) = All P)"
-  by (import hollight SURJECTIVE_FORALL_THM)
-
-lemma SURJECTIVE_EXISTS_THM: "(ALL y::'B. EX x::'A. (f::'A => 'B) x = y) =
-(ALL P::'B => bool. (EX x::'A. P (f x)) = Ex P)"
-  by (import hollight SURJECTIVE_EXISTS_THM)
-
-lemma SURJECTIVE_IMAGE_THM: "(ALL y::'B. EX x::'A. (f::'A => 'B) x = y) =
-(ALL x::'B => bool.
-    f ` {u::'A. EX xa::'A. x (f xa) & u = xa} =
-    {u::'B. EX xa::'B. x xa & u = xa})"
-  by (import hollight SURJECTIVE_IMAGE_THM)
-
-lemma IMAGE_INJECTIVE_IMAGE_OF_SUBSET: "EX x<=s::'A => bool.
-   (f::'A => 'B) ` s = f ` x &
-   (ALL (xa::'A) y::'A. xa : x & y : x & f xa = f y --> xa = y)"
-  by (import hollight IMAGE_INJECTIVE_IMAGE_OF_SUBSET)
-
-lemma INJECTIVE_ON_IMAGE: "(ALL (s::'A => bool) t::'A => bool.
-    s <= (u::'A => bool) & t <= u & (f::'A => 'B) ` s = f ` t --> s = t) =
-(ALL (x::'A) y::'A. x : u & y : u & f x = f y --> x = y)"
-  by (import hollight INJECTIVE_ON_IMAGE)
-
-lemma INJECTIVE_IMAGE: "(ALL (s::'A => bool) t::'A => bool. (f::'A => 'B) ` s = f ` t --> s = t) =
-(ALL (x::'A) y::'A. f x = f y --> x = y)"
-  by (import hollight INJECTIVE_IMAGE)
-
-lemma SURJECTIVE_ON_IMAGE: "(ALL t<=v::'B => bool. EX s<=u::'A => bool. (f::'A => 'B) ` s = t) =
-(ALL y::'B. y : v --> (EX x::'A. x : u & f x = y))"
-  by (import hollight SURJECTIVE_ON_IMAGE)
-
-lemma SURJECTIVE_IMAGE: "(ALL t::'B => bool. EX s::'A => bool. (f::'A => 'B) ` s = t) =
-(ALL y::'B. EX x::'A. f x = y)"
-  by (import hollight SURJECTIVE_IMAGE)
-
-lemma CARD_EQ_BIJECTION: "finite (s::'A => bool) & finite (t::'B => bool) & CARD s = CARD t
-==> EX f::'A => 'B.
-       (ALL x::'A. x : s --> f x : t) &
-       (ALL y::'B. y : t --> (EX x::'A. x : s & f x = y)) &
-       (ALL (x::'A) y::'A. x : s & y : s & f x = f y --> x = y)"
-  by (import hollight CARD_EQ_BIJECTION)
-
-lemma CARD_EQ_BIJECTIONS: "finite (s::'A => bool) & finite (t::'B => bool) & CARD s = CARD t
-==> EX (f::'A => 'B) g::'B => 'A.
-       (ALL x::'A. x : s --> f x : t & g (f x) = x) &
-       (ALL y::'B. y : t --> g y : s & f (g y) = y)"
-  by (import hollight CARD_EQ_BIJECTIONS)
-
-lemma BIJECTIONS_HAS_SIZE: "(ALL x::'A.
-    x : (s::'A => bool) -->
-    (f::'A => 'B) x : (t::'B => bool) & (g::'B => 'A) (f x) = x) &
-(ALL y::'B. y : t --> g y : s & f (g y) = y) & HAS_SIZE s (n::nat)
-==> HAS_SIZE t n"
-  by (import hollight BIJECTIONS_HAS_SIZE)
-
-lemma BIJECTIONS_HAS_SIZE_EQ: "(ALL x::'A.
-    x : (s::'A => bool) -->
-    (f::'A => 'B) x : (t::'B => bool) & (g::'B => 'A) (f x) = x) &
-(ALL y::'B. y : t --> g y : s & f (g y) = y)
-==> HAS_SIZE s (n::nat) = HAS_SIZE t n"
-  by (import hollight BIJECTIONS_HAS_SIZE_EQ)
-
-lemma BIJECTIONS_CARD_EQ: "(finite (s::'A => bool) | finite (t::'B => bool)) &
-(ALL x::'A. x : s --> (f::'A => 'B) x : t & (g::'B => 'A) (f x) = x) &
-(ALL y::'B. y : t --> g y : s & f (g y) = y)
-==> CARD s = CARD t"
-  by (import hollight BIJECTIONS_CARD_EQ)
-
-lemma WF_FINITE: "(ALL x::'A. ~ (u_556::'A => 'A => bool) x x) &
-(ALL (x::'A) (y::'A) z::'A. u_556 x y & u_556 y z --> u_556 x z) &
-(ALL x::'A. finite {u::'A. EX y::'A. u_556 y x & u = y})
-==> wfP u_556"
-  by (import hollight WF_FINITE)
-
-consts
-  "<=_c" :: "('q_58200 => bool) => ('q_58195 => bool) => bool" ("<='_c")
-
-defs
-  "<=_c_def": "<=_c ==
-%(u::'q_58200 => bool) ua::'q_58195 => bool.
-   EX f::'q_58200 => 'q_58195.
-      (ALL x::'q_58200. x : u --> f x : ua) &
-      (ALL (x::'q_58200) y::'q_58200. x : u & y : u & f x = f y --> x = y)"
-
-lemma DEF__lessthan__equal__c: "<=_c =
-(%(u::'q_58200 => bool) ua::'q_58195 => bool.
-    EX f::'q_58200 => 'q_58195.
-       (ALL x::'q_58200. x : u --> f x : ua) &
-       (ALL (x::'q_58200) y::'q_58200. x : u & y : u & f x = f y --> x = y))"
-  by (import hollight DEF__lessthan__equal__c)
-
-consts
-  "<_c" :: "('q_58212 => bool) => ('q_58213 => bool) => bool" ("<'_c")
-
-defs
-  "<_c_def": "<_c == %(u::'q_58212 => bool) ua::'q_58213 => bool. <=_c u ua & ~ <=_c ua u"
-
-lemma DEF__lessthan__c: "<_c = (%(u::'q_58212 => bool) ua::'q_58213 => bool. <=_c u ua & ~ <=_c ua u)"
-  by (import hollight DEF__lessthan__c)
-
-consts
-  "=_c" :: "('q_58264 => bool) => ('q_58261 => bool) => bool" ("='_c")
-
-defs
-  "=_c_def": "=_c ==
-%(u::'q_58264 => bool) ua::'q_58261 => bool.
-   EX f::'q_58264 => 'q_58261.
-      (ALL x::'q_58264. x : u --> f x : ua) &
-      (ALL y::'q_58261. y : ua --> (EX! x::'q_58264. x : u & f x = y))"
-
-lemma DEF__equal__c: "=_c =
-(%(u::'q_58264 => bool) ua::'q_58261 => bool.
-    EX f::'q_58264 => 'q_58261.
-       (ALL x::'q_58264. x : u --> f x : ua) &
-       (ALL y::'q_58261. y : ua --> (EX! x::'q_58264. x : u & f x = y)))"
-  by (import hollight DEF__equal__c)
-
-consts
-  ">=_c" :: "('q_58273 => bool) => ('q_58272 => bool) => bool" (">='_c")
-
-defs
-  ">=_c_def": ">=_c == %(u::'q_58273 => bool) ua::'q_58272 => bool. <=_c ua u"
-
-lemma DEF__greaterthan__equal__c: ">=_c = (%(u::'q_58273 => bool) ua::'q_58272 => bool. <=_c ua u)"
-  by (import hollight DEF__greaterthan__equal__c)
-
-consts
-  ">_c" :: "('q_58282 => bool) => ('q_58281 => bool) => bool" (">'_c")
-
-defs
-  ">_c_def": ">_c == %(u::'q_58282 => bool) ua::'q_58281 => bool. <_c ua u"
-
-lemma DEF__greaterthan__c: ">_c = (%(u::'q_58282 => bool) ua::'q_58281 => bool. <_c ua u)"
-  by (import hollight DEF__greaterthan__c)
-
-lemma LE_C: "<=_c (x::'q_58320 => bool) (xa::'q_58323 => bool) =
-(EX xb::'q_58323 => 'q_58320.
-    ALL xc::'q_58320. xc : x --> (EX x::'q_58323. x : xa & xb x = xc))"
-  by (import hollight LE_C)
-
-lemma GE_C: ">=_c (x::'q_58364 => bool) (xa::'q_58361 => bool) =
-(EX f::'q_58364 => 'q_58361.
-    ALL y::'q_58361. y : xa --> (EX xa::'q_58364. xa : x & y = f xa))"
-  by (import hollight GE_C)
-
-definition
-  COUNTABLE :: "('q_58372 => bool) => bool"  where
-  "(op ==::(('q_58372::type => bool) => bool)
-        => (('q_58372::type => bool) => bool) => prop)
- (COUNTABLE::('q_58372::type => bool) => bool)
- ((>=_c::(nat => bool) => ('q_58372::type => bool) => bool)
-   (UNIV::nat => bool))"
-
-lemma DEF_COUNTABLE: "(op =::(('q_58372::type => bool) => bool)
-       => (('q_58372::type => bool) => bool) => bool)
- (COUNTABLE::('q_58372::type => bool) => bool)
- ((>=_c::(nat => bool) => ('q_58372::type => bool) => bool)
-   (UNIV::nat => bool))"
-  by (import hollight DEF_COUNTABLE)
-
-lemma NUMSEG_COMBINE_R: "(x::nat) <= (xa::nat) + (1::nat) & xa <= (xb::nat)
-==> {x..xa} Un {xa + (1::nat)..xb} = {x..xb}"
-  by (import hollight NUMSEG_COMBINE_R)
-
-lemma NUMSEG_COMBINE_L: "(x::nat) <= (xa::nat) & xa <= (xb::nat) + (1::nat)
-==> {x..xa - (1::nat)} Un {xa..xb} = {x..xb}"
-  by (import hollight NUMSEG_COMBINE_L)
-
-lemma NUMSEG_LREC: "(x::nat) <= (xa::nat) ==> insert x {x + (1::nat)..xa} = {x..xa}"
-  by (import hollight NUMSEG_LREC)
-
-lemma NUMSEG_RREC: "(x::nat) <= (xa::nat) ==> insert xa {x..xa - (1::nat)} = {x..xa}"
-  by (import hollight NUMSEG_RREC)
-
-lemma IN_NUMSEG_0: "((x::nat) : {0::nat..xa::nat}) = (x <= xa)"
-  by (import hollight IN_NUMSEG_0)
-
-lemma NUMSEG_EMPTY: "({x::nat..xa::nat} = {}) = (xa < x)"
-  by (import hollight NUMSEG_EMPTY)
-
-lemma CARD_NUMSEG_LEMMA: "CARD {m..m + d} = d + 1"
-  by (import hollight CARD_NUMSEG_LEMMA)
-
-lemma CARD_NUMSEG: "CARD {m..n} = n + 1 - m"
-  by (import hollight CARD_NUMSEG)
-
-lemma HAS_SIZE_NUMSEG: "HAS_SIZE {x..xa} (xa + 1 - x)"
-  by (import hollight HAS_SIZE_NUMSEG)
-
-lemma CARD_NUMSEG_1: "CARD {1..x} = x"
-  by (import hollight CARD_NUMSEG_1)
-
-lemma HAS_SIZE_NUMSEG_1: "HAS_SIZE {1..x} x"
-  by (import hollight HAS_SIZE_NUMSEG_1)
-
-lemma NUMSEG_CLAUSES: "(ALL m::nat. {m..0::nat} = (if m = (0::nat) then {0::nat} else {})) &
-(ALL (m::nat) n::nat.
-    {m..Suc n} = (if m <= Suc n then insert (Suc n) {m..n} else {m..n}))"
-  by (import hollight NUMSEG_CLAUSES)
-
-lemma FINITE_INDEX_NUMSEG: "finite (s::'A => bool) =
-(EX f::nat => 'A.
-    (ALL (i::nat) j::nat.
-        i : {1::nat..CARD s} & j : {1::nat..CARD s} & f i = f j --> i = j) &
-    s = f ` {1::nat..CARD s})"
-  by (import hollight FINITE_INDEX_NUMSEG)
-
-lemma FINITE_INDEX_NUMBERS: "finite (s::'A => bool) =
-(EX (k::nat => bool) f::nat => 'A.
-    (ALL (i::nat) j::nat. i : k & j : k & f i = f j --> i = j) &
-    finite k & s = f ` k)"
-  by (import hollight FINITE_INDEX_NUMBERS)
-
-lemma DISJOINT_NUMSEG: "({x::nat..xa::nat} Int {xb::nat..xc::nat} = {}) =
-(xa < xb | xc < x | xa < x | xc < xb)"
-  by (import hollight DISJOINT_NUMSEG)
-
-lemma NUMSEG_ADD_SPLIT: "(x::nat) <= (xa::nat) + (1::nat)
-==> {x..xa + (xb::nat)} = {x..xa} Un {xa + (1::nat)..xa + xb}"
-  by (import hollight NUMSEG_ADD_SPLIT)
-
-lemma SUBSET_NUMSEG: "({m::nat..n::nat} <= {p::nat..q::nat}) = (n < m | p <= m & n <= q)"
-  by (import hollight SUBSET_NUMSEG)
-
-lemma NUMSEG_LE: "{u::nat. EX xa<=x::nat. u = xa} = {0::nat..x}"
-  by (import hollight NUMSEG_LE)
-
-lemma NUMSEG_LT: "{u::nat. EX x<n::nat. u = x} =
-(if n = (0::nat) then {} else {0::nat..n - (1::nat)})"
-  by (import hollight NUMSEG_LT)
-
-lemma TOPOLOGICAL_SORT: "[| (ALL (x::'A) y::'A.
-       (u_556::'A => 'A => bool) x y & u_556 y x --> x = y) &
-   (ALL (x::'A) (y::'A) z::'A. u_556 x y & u_556 y z --> u_556 x z);
-   HAS_SIZE (s::'A => bool) (n::nat) |]
-==> EX f::nat => 'A.
-       s = f ` {1::nat..n} &
-       (ALL (j::nat) k::nat.
-           j : {1::nat..n} & k : {1::nat..n} & j < k -->
-           ~ u_556 (f k) (f j))"
-  by (import hollight TOPOLOGICAL_SORT)
-
-lemma FINITE_INTSEG: "(ALL l r. finite {u. EX x. (int_le l x & int_le x r) & u = x}) &
-(ALL l r. finite {u. EX x. (int_le l x & int_lt x r) & u = x}) &
-(ALL l r. finite {u. EX x. (int_lt l x & int_le x r) & u = x}) &
-(ALL l r. finite {u. EX x. (int_lt l x & int_lt x r) & u = x})"
-  by (import hollight FINITE_INTSEG)
-
-definition
-  neutral :: "('q_59899 => 'q_59899 => 'q_59899) => 'q_59899"  where
-  "neutral ==
-%u::'q_59899 => 'q_59899 => 'q_59899.
-   SOME x::'q_59899. ALL y::'q_59899. u x y = y & u y x = y"
-
-lemma DEF_neutral: "neutral =
-(%u::'q_59899 => 'q_59899 => 'q_59899.
-    SOME x::'q_59899. ALL y::'q_59899. u x y = y & u y x = y)"
-  by (import hollight DEF_neutral)
-
-definition
-  monoidal :: "('A => 'A => 'A) => bool"  where
-  "monoidal ==
-%u::'A => 'A => 'A.
-   (ALL (x::'A) y::'A. u x y = u y x) &
-   (ALL (x::'A) (y::'A) z::'A. u x (u y z) = u (u x y) z) &
-   (ALL x::'A. u (neutral u) x = x)"
-
-lemma DEF_monoidal: "monoidal =
-(%u::'A => 'A => 'A.
-    (ALL (x::'A) y::'A. u x y = u y x) &
-    (ALL (x::'A) (y::'A) z::'A. u x (u y z) = u (u x y) z) &
-    (ALL x::'A. u (neutral u) x = x))"
-  by (import hollight DEF_monoidal)
-
-lemma MONOIDAL_AC: "monoidal (x::'q_60055 => 'q_60055 => 'q_60055)
-==> (ALL a::'q_60055. x (neutral x) a = a) &
-    (ALL a::'q_60055. x a (neutral x) = a) &
-    (ALL (a::'q_60055) b::'q_60055. x a b = x b a) &
-    (ALL (a::'q_60055) (b::'q_60055) c::'q_60055.
-        x (x a b) c = x a (x b c)) &
-    (ALL (a::'q_60055) (b::'q_60055) c::'q_60055. x a (x b c) = x b (x a c))"
-  by (import hollight MONOIDAL_AC)
-
-definition
-  support :: "('B => 'B => 'B) => ('A => 'B) => ('A => bool) => 'A => bool"  where
-  "support ==
-%(u::'B => 'B => 'B) (ua::'A => 'B) ub::'A => bool.
-   {uc::'A. EX x::'A. (x : ub & ua x ~= neutral u) & uc = x}"
-
-lemma DEF_support: "support =
-(%(u::'B => 'B => 'B) (ua::'A => 'B) ub::'A => bool.
-    {uc::'A. EX x::'A. (x : ub & ua x ~= neutral u) & uc = x})"
-  by (import hollight DEF_support)
-
-definition
-  iterate :: "('q_60113 => 'q_60113 => 'q_60113)
-=> ('A => bool) => ('A => 'q_60113) => 'q_60113"  where
-  "iterate ==
-%(u::'q_60113 => 'q_60113 => 'q_60113) (ua::'A => bool) ub::'A => 'q_60113.
-   if finite (support u ub ua)
-   then ITSET (%x::'A. u (ub x)) (support u ub ua) (neutral u)
-   else neutral u"
-
-lemma DEF_iterate: "iterate =
-(%(u::'q_60113 => 'q_60113 => 'q_60113) (ua::'A => bool) ub::'A => 'q_60113.
-    if finite (support u ub ua)
-    then ITSET (%x::'A. u (ub x)) (support u ub ua) (neutral u)
-    else neutral u)"
-  by (import hollight DEF_iterate)
-
-lemma IN_SUPPORT: "((xb::'q_60163)
- : support (x::'q_60160 => 'q_60160 => 'q_60160) (xa::'q_60163 => 'q_60160)
-    (xc::'q_60163 => bool)) =
-(xb : xc & xa xb ~= neutral x)"
-  by (import hollight IN_SUPPORT)
-
-lemma SUPPORT_SUPPORT: "support (x::'q_60185 => 'q_60185 => 'q_60185) (xa::'q_60196 => 'q_60185)
- (support x xa (xb::'q_60196 => bool)) =
-support x xa xb"
-  by (import hollight SUPPORT_SUPPORT)
-
-lemma SUPPORT_EMPTY: "(ALL xc::'q_60235.
-    xc : (xb::'q_60235 => bool) -->
-    (xa::'q_60235 => 'q_60221) xc =
-    neutral (x::'q_60221 => 'q_60221 => 'q_60221)) =
-(support x xa xb = {})"
-  by (import hollight SUPPORT_EMPTY)
-
-lemma SUPPORT_SUBSET: "support (x::'q_60255 => 'q_60255 => 'q_60255) (xa::'q_60256 => 'q_60255)
- (xb::'q_60256 => bool)
-<= xb"
-  by (import hollight SUPPORT_SUBSET)
-
-lemma FINITE_SUPPORT: "finite (s::'q_60273 => bool)
-==> finite
-     (support (u::'q_60279 => 'q_60279 => 'q_60279)
-       (f::'q_60273 => 'q_60279) s)"
-  by (import hollight FINITE_SUPPORT)
-
-lemma SUPPORT_CLAUSES: "(ALL x::'q_60297 => 'q_60530.
-    support (u_4371::'q_60530 => 'q_60530 => 'q_60530) x {} = {}) &
-(ALL (x::'q_60345 => 'q_60530) (xa::'q_60345) xb::'q_60345 => bool.
-    support u_4371 x (insert xa xb) =
-    (if x xa = neutral u_4371 then support u_4371 x xb
-     else insert xa (support u_4371 x xb))) &
-(ALL (x::'q_60378 => 'q_60530) (xa::'q_60378) xb::'q_60378 => bool.
-    support u_4371 x (xb - {xa}) = support u_4371 x xb - {xa}) &
-(ALL (x::'q_60416 => 'q_60530) (xa::'q_60416 => bool) xb::'q_60416 => bool.
-    support u_4371 x (xa Un xb) =
-    support u_4371 x xa Un support u_4371 x xb) &
-(ALL (x::'q_60454 => 'q_60530) (xa::'q_60454 => bool) xb::'q_60454 => bool.
-    support u_4371 x (xa Int xb) =
-    support u_4371 x xa Int support u_4371 x xb) &
-(ALL (x::'q_60492 => 'q_60530) (xa::'q_60492 => bool) xb::'q_60492 => bool.
-    support u_4371 x (xa - xb) =
-    support u_4371 x xa - support u_4371 x xb) &
-(ALL (x::'q_60529 => 'q_60520) (xa::'q_60520 => 'q_60530)
-    xb::'q_60529 => bool.
-    support u_4371 xa (x ` xb) = x ` support u_4371 (xa o x) xb)"
-  by (import hollight SUPPORT_CLAUSES)
-
-lemma SUPPORT_DELTA: "support (x::'q_60556 => 'q_60556 => 'q_60556)
- (%xa::'q_60584.
-     if xa = (xc::'q_60584) then (xb::'q_60584 => 'q_60556) xa
-     else neutral x)
- (xa::'q_60584 => bool) =
-(if xc : xa then support x xb {xc} else {})"
-  by (import hollight SUPPORT_DELTA)
-
-lemma FINITE_SUPPORT_DELTA: "finite
- (support (x::'q_60605 => 'q_60605 => 'q_60605)
-   (%xc::'q_60614.
-       if xc = (xb::'q_60614) then (xa::'q_60614 => 'q_60605) xc
-       else neutral x)
-   (s::'q_60614 => bool))"
-  by (import hollight FINITE_SUPPORT_DELTA)
-
-lemma ITERATE_SUPPORT: "iterate (x::'q_60630 => 'q_60630 => 'q_60630)
- (support x (xa::'q_60642 => 'q_60630) (xb::'q_60642 => bool)) xa =
-iterate x xb xa"
-  by (import hollight ITERATE_SUPPORT)
-
-lemma ITERATE_EXPAND_CASES: "iterate (x::'q_60661 => 'q_60661 => 'q_60661) (xb::'q_60667 => bool)
- (xa::'q_60667 => 'q_60661) =
-(if finite (support x xa xb) then iterate x (support x xa xb) xa
- else neutral x)"
-  by (import hollight ITERATE_EXPAND_CASES)
-
-lemma ITERATE_CLAUSES_GEN: "monoidal (u_4371::'B => 'B => 'B)
-==> (ALL f::'A => 'B. iterate u_4371 {} f = neutral u_4371) &
-    (ALL (f::'A => 'B) (x::'A) s::'A => bool.
-        monoidal u_4371 & finite (support u_4371 f s) -->
-        iterate u_4371 (insert x s) f =
-        (if x : s then iterate u_4371 s f
-         else u_4371 (f x) (iterate u_4371 s f)))"
-  by (import hollight ITERATE_CLAUSES_GEN)
-
-lemma ITERATE_CLAUSES: "monoidal (x::'q_60857 => 'q_60857 => 'q_60857)
-==> (ALL f::'q_60815 => 'q_60857. iterate x {} f = neutral x) &
-    (ALL (f::'q_60859 => 'q_60857) (xa::'q_60859) s::'q_60859 => bool.
-        finite s -->
-        iterate x (insert xa s) f =
-        (if xa : s then iterate x s f else x (f xa) (iterate x s f)))"
-  by (import hollight ITERATE_CLAUSES)
-
-lemma ITERATE_UNION: "[| monoidal (u_4371::'q_60945 => 'q_60945 => 'q_60945);
-   finite (s::'q_60930 => bool) &
-   finite (x::'q_60930 => bool) & s Int x = {} |]
-==> iterate u_4371 (s Un x) (f::'q_60930 => 'q_60945) =
-    u_4371 (iterate u_4371 s f) (iterate u_4371 x f)"
-  by (import hollight ITERATE_UNION)
-
-lemma ITERATE_UNION_GEN: "[| monoidal (x::'B => 'B => 'B);
-   finite (support x (xa::'A => 'B) (xb::'A => bool)) &
-   finite (support x xa (xc::'A => bool)) &
-   support x xa xb Int support x xa xc = {} |]
-==> iterate x (xb Un xc) xa = x (iterate x xb xa) (iterate x xc xa)"
-  by (import hollight ITERATE_UNION_GEN)
-
-lemma ITERATE_DIFF: "[| monoidal (u::'q_61087 => 'q_61087 => 'q_61087);
-   finite (s::'q_61083 => bool) & (t::'q_61083 => bool) <= s |]
-==> u (iterate u (s - t) (f::'q_61083 => 'q_61087)) (iterate u t f) =
-    iterate u s f"
-  by (import hollight ITERATE_DIFF)
-
-lemma ITERATE_DIFF_GEN: "[| monoidal (x::'B => 'B => 'B);
-   finite (support x (xa::'A => 'B) (xb::'A => bool)) &
-   support x xa (xc::'A => bool) <= support x xa xb |]
-==> x (iterate x (xb - xc) xa) (iterate x xc xa) = iterate x xb xa"
-  by (import hollight ITERATE_DIFF_GEN)
-
-lemma ITERATE_INCL_EXCL: "[| monoidal (u_4371::'q_61316 => 'q_61316 => 'q_61316);
-   finite (s::'q_61298 => bool) & finite (t::'q_61298 => bool) |]
-==> u_4371 (iterate u_4371 s (f::'q_61298 => 'q_61316))
-     (iterate u_4371 t f) =
-    u_4371 (iterate u_4371 (s Un t) f) (iterate u_4371 (s Int t) f)"
-  by (import hollight ITERATE_INCL_EXCL)
-
-lemma ITERATE_CLOSED: "[| monoidal (u_4371::'B => 'B => 'B);
-   (P::'B => bool) (neutral u_4371) &
-   (ALL (x::'B) y::'B. P x & P y --> P (u_4371 x y));
-   !!x::'A.
-      x : (s::'A => bool) & (f::'A => 'B) x ~= neutral u_4371 ==> P (f x) |]
-==> P (iterate u_4371 s f)"
-  by (import hollight ITERATE_CLOSED)
-
-lemma ITERATE_RELATED: "[| monoidal (u_4371::'B => 'B => 'B);
-   (R::'B => 'B => bool) (neutral u_4371) (neutral u_4371) &
-   (ALL (x1::'B) (y1::'B) (x2::'B) y2::'B.
-       R x1 x2 & R y1 y2 --> R (u_4371 x1 y1) (u_4371 x2 y2));
-   finite (x::'A => bool) &
-   (ALL xa::'A. xa : x --> R ((f::'A => 'B) xa) ((g::'A => 'B) xa)) |]
-==> R (iterate u_4371 x f) (iterate u_4371 x g)"
-  by (import hollight ITERATE_RELATED)
-
-lemma ITERATE_EQ_NEUTRAL: "[| monoidal (u_4371::'B => 'B => 'B);
-   !!x::'A. x : (s::'A => bool) ==> (f::'A => 'B) x = neutral u_4371 |]
-==> iterate u_4371 s f = neutral u_4371"
-  by (import hollight ITERATE_EQ_NEUTRAL)
-
-lemma ITERATE_SING: "monoidal (x::'B => 'B => 'B) ==> iterate x {xa::'A} (f::'A => 'B) = f xa"
-  by (import hollight ITERATE_SING)
-
-lemma ITERATE_DELETE: "[| monoidal (u::'B => 'B => 'B); finite (s::'A => bool) & (a::'A) : s |]
-==> u ((f::'A => 'B) a) (iterate u (s - {a}) f) = iterate u s f"
-  by (import hollight ITERATE_DELETE)
-
-lemma ITERATE_DELTA: "monoidal (u_4371::'q_61672 => 'q_61672 => 'q_61672)
-==> iterate u_4371 (xb::'q_61691 => bool)
-     (%xb::'q_61691.
-         if xb = (xa::'q_61691) then (x::'q_61691 => 'q_61672) xb
-         else neutral u_4371) =
-    (if xa : xb then x xa else neutral u_4371)"
-  by (import hollight ITERATE_DELTA)
-
-lemma ITERATE_IMAGE: "[| monoidal (u_4371::'C => 'C => 'C);
-   !!(x::'A) y::'A.
-      x : (s::'A => bool) & y : s & (f::'A => 'B) x = f y ==> x = y |]
-==> iterate u_4371 (f ` s) (g::'B => 'C) = iterate u_4371 s (g o f)"
-  by (import hollight ITERATE_IMAGE)
-
-lemma ITERATE_BIJECTION: "[| monoidal (u_4371::'B => 'B => 'B);
-   (ALL x::'A. x : (s::'A => bool) --> (p::'A => 'A) x : s) &
-   (ALL y::'A. y : s --> (EX! x::'A. x : s & p x = y)) |]
-==> iterate u_4371 s (f::'A => 'B) = iterate u_4371 s (f o p)"
-  by (import hollight ITERATE_BIJECTION)
-
-lemma ITERATE_ITERATE_PRODUCT: "[| monoidal (u_4371::'C => 'C => 'C);
-   finite (x::'A => bool) &
-   (ALL i::'A. i : x --> finite ((xa::'A => 'B => bool) i)) |]
-==> iterate u_4371 x
-     (%i::'A. iterate u_4371 (xa i) ((xb::'A => 'B => 'C) i)) =
-    iterate u_4371
-     {u::'A * 'B. EX (i::'A) j::'B. (i : x & j : xa i) & u = (i, j)}
-     (SOME f::'A * 'B => 'C. ALL (i::'A) j::'B. f (i, j) = xb i j)"
-  by (import hollight ITERATE_ITERATE_PRODUCT)
-
-lemma ITERATE_EQ: "[| monoidal (u_4371::'B => 'B => 'B);
-   !!x::'A. x : (s::'A => bool) ==> (f::'A => 'B) x = (g::'A => 'B) x |]
-==> iterate u_4371 s f = iterate u_4371 s g"
-  by (import hollight ITERATE_EQ)
-
-lemma ITERATE_EQ_GENERAL: "[| monoidal (u_4371::'C => 'C => 'C);
-   (ALL y::'B.
-       y : (t::'B => bool) -->
-       (EX! x::'A. x : (s::'A => bool) & (h::'A => 'B) x = y)) &
-   (ALL x::'A. x : s --> h x : t & (g::'B => 'C) (h x) = (f::'A => 'C) x) |]
-==> iterate u_4371 s f = iterate u_4371 t g"
-  by (import hollight ITERATE_EQ_GENERAL)
-
-lemma ITERATE_EQ_GENERAL_INVERSES: "[| monoidal (u_4371::'C => 'C => 'C);
-   (ALL y::'B.
-       y : (t::'B => bool) -->
-       (k::'B => 'A) y : (s::'A => bool) & (h::'A => 'B) (k y) = y) &
-   (ALL x::'A.
-       x : s -->
-       h x : t & k (h x) = x & (g::'B => 'C) (h x) = (f::'A => 'C) x) |]
-==> iterate u_4371 s f = iterate u_4371 t g"
-  by (import hollight ITERATE_EQ_GENERAL_INVERSES)
-
-lemma ITERATE_INJECTION: "[| monoidal (u_4371::'B => 'B => 'B);
-   finite (s::'A => bool) &
-   (ALL x::'A. x : s --> (p::'A => 'A) x : s) &
-   (ALL (x::'A) y::'A. x : s & y : s & p x = p y --> x = y) |]
-==> iterate u_4371 s ((f::'A => 'B) o p) = iterate u_4371 s f"
-  by (import hollight ITERATE_INJECTION)
-
-lemma ITERATE_UNION_NONZERO: "[| monoidal (u_4371::'B => 'B => 'B);
-   finite (s::'A => bool) &
-   finite (t::'A => bool) &
-   (ALL x::'A. x : s Int t --> (f::'A => 'B) x = neutral u_4371) |]
-==> iterate u_4371 (s Un t) f =
-    u_4371 (iterate u_4371 s f) (iterate u_4371 t f)"
-  by (import hollight ITERATE_UNION_NONZERO)
-
-lemma ITERATE_OP: "[| monoidal (u_4371::'q_62649 => 'q_62649 => 'q_62649);
-   finite (s::'q_62648 => bool) |]
-==> iterate u_4371 s
-     (%x::'q_62648.
-         u_4371 ((f::'q_62648 => 'q_62649) x)
-          ((g::'q_62648 => 'q_62649) x)) =
-    u_4371 (iterate u_4371 s f) (iterate u_4371 s g)"
-  by (import hollight ITERATE_OP)
-
-lemma ITERATE_SUPERSET: "[| monoidal (u_4371::'B => 'B => 'B);
-   (u::'A => bool) <= (v::'A => bool) &
-   (ALL x::'A. x : v & x ~: u --> (f::'A => 'B) x = neutral u_4371) |]
-==> iterate u_4371 v f = iterate u_4371 u f"
-  by (import hollight ITERATE_SUPERSET)
-
-lemma ITERATE_IMAGE_NONZERO: "[| monoidal (u_4371::'C => 'C => 'C);
-   finite (x::'A => bool) &
-   (ALL (xa::'A) y::'A.
-       xa : x & y : x & xa ~= y & (f::'A => 'B) xa = f y -->
-       (g::'B => 'C) (f xa) = neutral u_4371) |]
-==> iterate u_4371 (f ` x) g = iterate u_4371 x (g o f)"
-  by (import hollight ITERATE_IMAGE_NONZERO)
-
-lemma ITERATE_CASES: "[| monoidal (u_4371::'B => 'B => 'B); finite (s::'A => bool) |]
-==> iterate u_4371 s
-     (%x::'A.
-         if (P::'A => bool) x then (f::'A => 'B) x else (g::'A => 'B) x) =
-    u_4371 (iterate u_4371 {u::'A. EX x::'A. (x : s & P x) & u = x} f)
-     (iterate u_4371 {u::'A. EX x::'A. (x : s & ~ P x) & u = x} g)"
-  by (import hollight ITERATE_CASES)
-
-lemma ITERATE_OP_GEN: "[| monoidal (u_4371::'B => 'B => 'B);
-   finite (support u_4371 (f::'A => 'B) (s::'A => bool)) &
-   finite (support u_4371 (g::'A => 'B) s) |]
-==> iterate u_4371 s (%x::'A. u_4371 (f x) (g x)) =
-    u_4371 (iterate u_4371 s f) (iterate u_4371 s g)"
-  by (import hollight ITERATE_OP_GEN)
-
-lemma ITERATE_CLAUSES_NUMSEG: "monoidal (x::'q_63246 => 'q_63246 => 'q_63246)
-==> (ALL xa::nat.
-        iterate x {xa..0::nat} (f::nat => 'q_63246) =
-        (if xa = (0::nat) then f (0::nat) else neutral x)) &
-    (ALL (xa::nat) xb::nat.
-        iterate x {xa..Suc xb} f =
-        (if xa <= Suc xb then x (iterate x {xa..xb} f) (f (Suc xb))
-         else iterate x {xa..xb} f))"
-  by (import hollight ITERATE_CLAUSES_NUMSEG)
-
-lemma ITERATE_PAIR: "monoidal (u_4371::'q_63421 => 'q_63421 => 'q_63421)
-==> iterate u_4371 {(2::nat) * (m::nat)..(2::nat) * (n::nat) + (1::nat)}
-     (f::nat => 'q_63421) =
-    iterate u_4371 {m..n}
-     (%i::nat. u_4371 (f ((2::nat) * i)) (f ((2::nat) * i + (1::nat))))"
-  by (import hollight ITERATE_PAIR)
-
-definition
-  nsum :: "('q_63439 => bool) => ('q_63439 => nat) => nat"  where
-  "(op ==::(('q_63439::type => bool) => ('q_63439::type => nat) => nat)
-        => (('q_63439::type => bool) => ('q_63439::type => nat) => nat)
-           => prop)
- (nsum::('q_63439::type => bool) => ('q_63439::type => nat) => nat)
- ((iterate::(nat => nat => nat)
-            => ('q_63439::type => bool) => ('q_63439::type => nat) => nat)
-   (op +::nat => nat => nat))"
-
-lemma DEF_nsum: "(op =::(('q_63439::type => bool) => ('q_63439::type => nat) => nat)
-       => (('q_63439::type => bool) => ('q_63439::type => nat) => nat)
-          => bool)
- (nsum::('q_63439::type => bool) => ('q_63439::type => nat) => nat)
- ((iterate::(nat => nat => nat)
-            => ('q_63439::type => bool) => ('q_63439::type => nat) => nat)
-   (op +::nat => nat => nat))"
-  by (import hollight DEF_nsum)
-
-lemma NEUTRAL_ADD: "neutral op + = (0::nat)"
-  by (import hollight NEUTRAL_ADD)
-
-lemma NEUTRAL_MUL: "neutral op * = (1::nat)"
-  by (import hollight NEUTRAL_MUL)
-
-lemma MONOIDAL_ADD: "(monoidal::(nat => nat => nat) => bool) (op +::nat => nat => nat)"
-  by (import hollight MONOIDAL_ADD)
-
-lemma MONOIDAL_MUL: "(monoidal::(nat => nat => nat) => bool) (op *::nat => nat => nat)"
-  by (import hollight MONOIDAL_MUL)
-
-lemma NSUM_CLAUSES: "(ALL x::'q_63477 => nat. nsum {} x = (0::nat)) &
-(ALL (x::'q_63516) (xa::'q_63516 => nat) xb::'q_63516 => bool.
-    finite xb -->
-    nsum (insert x xb) xa =
-    (if x : xb then nsum xb xa else xa x + nsum xb xa))"
-  by (import hollight NSUM_CLAUSES)
-
-lemma NSUM_UNION: "finite (xa::'q_63542 => bool) &
-finite (xb::'q_63542 => bool) & xa Int xb = {}
-==> nsum (xa Un xb) (x::'q_63542 => nat) = nsum xa x + nsum xb x"
-  by (import hollight NSUM_UNION)
-
-lemma NSUM_DIFF: "finite (s::'q_63597 => bool) & (t::'q_63597 => bool) <= s
-==> nsum (s - t) (f::'q_63597 => nat) = nsum s f - nsum t f"
-  by (import hollight NSUM_DIFF)
-
-lemma NSUM_INCL_EXCL: "finite (x::'A => bool) & finite (xa::'A => bool)
-==> nsum x (xb::'A => nat) + nsum xa xb =
-    nsum (x Un xa) xb + nsum (x Int xa) xb"
-  by (import hollight NSUM_INCL_EXCL)
-
-lemma NSUM_SUPPORT: "nsum (support op + (x::'q_63686 => nat) (xa::'q_63686 => bool)) x =
-nsum xa x"
-  by (import hollight NSUM_SUPPORT)
-
-lemma NSUM_ADD: "finite (xb::'q_63720 => bool)
-==> nsum xb
-     (%xb::'q_63720. (x::'q_63720 => nat) xb + (xa::'q_63720 => nat) xb) =
-    nsum xb x + nsum xb xa"
-  by (import hollight NSUM_ADD)
-
-lemma NSUM_ADD_GEN: "finite
- {xa::'q_63807.
-  EX xc::'q_63807.
-     (xc : (xb::'q_63807 => bool) & (x::'q_63807 => nat) xc ~= (0::nat)) &
-     xa = xc} &
-finite
- {x::'q_63807.
-  EX xc::'q_63807.
-     (xc : xb & (xa::'q_63807 => nat) xc ~= (0::nat)) & x = xc}
-==> nsum xb (%xb::'q_63807. x xb + xa xb) = nsum xb x + nsum xb xa"
-  by (import hollight NSUM_ADD_GEN)
-
-lemma NSUM_EQ_0: "(!!xb::'A. xb : (xa::'A => bool) ==> (x::'A => nat) xb = (0::nat))
-==> nsum xa x = (0::nat)"
-  by (import hollight NSUM_EQ_0)
-
-lemma NSUM_0: "nsum (x::'A => bool) (%n::'A. 0::nat) = (0::nat)"
-  by (import hollight NSUM_0)
-
-lemma NSUM_LMUL: "nsum (s::'A => bool) (%x::'A. (c::nat) * (f::'A => nat) x) = c * nsum s f"
-  by (import hollight NSUM_LMUL)
-
-lemma NSUM_RMUL: "nsum (xb::'A => bool) (%xb::'A. (x::'A => nat) xb * (xa::nat)) =
-nsum xb x * xa"
-  by (import hollight NSUM_RMUL)
-
-lemma NSUM_LE: "finite (xb::'q_63997 => bool) &
-(ALL xc::'q_63997.
-    xc : xb --> (x::'q_63997 => nat) xc <= (xa::'q_63997 => nat) xc)
-==> nsum xb x <= nsum xb xa"
-  by (import hollight NSUM_LE)
-
-lemma NSUM_LT: "finite (s::'A => bool) &
-(ALL x::'A. x : s --> (f::'A => nat) x <= (g::'A => nat) x) &
-(EX x::'A. x : s & f x < g x)
-==> nsum s f < nsum s g"
-  by (import hollight NSUM_LT)
-
-lemma NSUM_LT_ALL: "finite (s::'q_64119 => bool) &
-s ~= {} &
-(ALL x::'q_64119. x : s --> (f::'q_64119 => nat) x < (g::'q_64119 => nat) x)
-==> nsum s f < nsum s g"
-  by (import hollight NSUM_LT_ALL)
-
-lemma NSUM_EQ: "(!!xc::'q_64157.
-    xc : (xb::'q_64157 => bool)
-    ==> (x::'q_64157 => nat) xc = (xa::'q_64157 => nat) xc)
-==> nsum xb x = nsum xb xa"
-  by (import hollight NSUM_EQ)
-
-lemma NSUM_CONST: "finite (s::'q_64187 => bool) ==> nsum s (%n::'q_64187. c::nat) = CARD s * c"
-  by (import hollight NSUM_CONST)
-
-lemma NSUM_POS_BOUND: "[| finite (x::'A => bool) & nsum x (f::'A => nat) <= (b::nat);
-   (xa::'A) : x |]
-==> f xa <= b"
-  by (import hollight NSUM_POS_BOUND)
-
-lemma NSUM_EQ_0_IFF: "finite (s::'q_64296 => bool)
-==> (nsum s (f::'q_64296 => nat) = (0::nat)) =
-    (ALL x::'q_64296. x : s --> f x = (0::nat))"
-  by (import hollight NSUM_EQ_0_IFF)
-
-lemma NSUM_DELETE: "finite (xa::'q_64325 => bool) & (xb::'q_64325) : xa
-==> (x::'q_64325 => nat) xb + nsum (xa - {xb}) x = nsum xa x"
-  by (import hollight NSUM_DELETE)
-
-lemma NSUM_SING: "nsum {xa::'q_64354} (x::'q_64354 => nat) = x xa"
-  by (import hollight NSUM_SING)
-
-lemma NSUM_DELTA: "nsum (x::'A => bool) (%x::'A. if x = (xa::'A) then b::nat else (0::nat)) =
-(if xa : x then b else (0::nat))"
-  by (import hollight NSUM_DELTA)
-
-lemma NSUM_SWAP: "finite (x::'A => bool) & finite (xa::'B => bool)
-==> nsum x (%i::'A. nsum xa ((f::'A => 'B => nat) i)) =
-    nsum xa (%j::'B. nsum x (%i::'A. f i j))"
-  by (import hollight NSUM_SWAP)
-
-lemma NSUM_IMAGE: "(!!(xa::'q_64490) y::'q_64490.
-    xa : (xb::'q_64490 => bool) &
-    y : xb & (x::'q_64490 => 'q_64466) xa = x y
-    ==> xa = y)
-==> nsum (x ` xb) (xa::'q_64466 => nat) = nsum xb (xa o x)"
-  by (import hollight NSUM_IMAGE)
-
-lemma NSUM_SUPERSET: "(xa::'A => bool) <= (xb::'A => bool) &
-(ALL xc::'A. xc : xb & xc ~: xa --> (x::'A => nat) xc = (0::nat))
-==> nsum xb x = nsum xa x"
-  by (import hollight NSUM_SUPERSET)
-
-lemma NSUM_UNION_RZERO: "finite (u::'A => bool) &
-(ALL x::'A. x : (v::'A => bool) & x ~: u --> (f::'A => nat) x = (0::nat))
-==> nsum (u Un v) f = nsum u f"
-  by (import hollight NSUM_UNION_RZERO)
-
-lemma NSUM_UNION_LZERO: "finite (v::'A => bool) &
-(ALL x::'A. x : (u::'A => bool) & x ~: v --> (f::'A => nat) x = (0::nat))
-==> nsum (u Un v) f = nsum v f"
-  by (import hollight NSUM_UNION_LZERO)
-
-lemma NSUM_RESTRICT: "finite (s::'q_64681 => bool)
-==> nsum s
-     (%x::'q_64681. if x : s then (f::'q_64681 => nat) x else (0::nat)) =
-    nsum s f"
-  by (import hollight NSUM_RESTRICT)
-
-lemma NSUM_BOUND: "finite (x::'A => bool) &
-(ALL xc::'A. xc : x --> (xa::'A => nat) xc <= (xb::nat))
-==> nsum x xa <= CARD x * xb"
-  by (import hollight NSUM_BOUND)
-
-lemma NSUM_BOUND_GEN: "finite (x::'A => bool) &
-x ~= {} & (ALL xa::'A. xa : x --> (f::'A => nat) xa <= (b::nat) div CARD x)
-==> nsum x f <= b"
-  by (import hollight NSUM_BOUND_GEN)
-
-lemma NSUM_BOUND_LT: "finite (s::'A => bool) &
-(ALL x::'A. x : s --> (f::'A => nat) x <= (b::nat)) &
-(EX x::'A. x : s & f x < b)
-==> nsum s f < CARD s * b"
-  by (import hollight NSUM_BOUND_LT)
-
-lemma NSUM_BOUND_LT_ALL: "finite (s::'q_64899 => bool) &
-s ~= {} & (ALL x::'q_64899. x : s --> (f::'q_64899 => nat) x < (b::nat))
-==> nsum s f < CARD s * b"
-  by (import hollight NSUM_BOUND_LT_ALL)
-
-lemma NSUM_BOUND_LT_GEN: "finite (s::'A => bool) &
-s ~= {} & (ALL x::'A. x : s --> (f::'A => nat) x < (b::nat) div CARD s)
-==> nsum s f < b"
-  by (import hollight NSUM_BOUND_LT_GEN)
-
-lemma NSUM_UNION_EQ: "finite (u::'q_65000 => bool) &
-(s::'q_65000 => bool) Int (t::'q_65000 => bool) = {} & s Un t = u
-==> nsum s (f::'q_65000 => nat) + nsum t f = nsum u f"
-  by (import hollight NSUM_UNION_EQ)
-
-lemma NSUM_EQ_SUPERSET: "finite (t::'A => bool) &
-t <= (s::'A => bool) &
-(ALL x::'A. x : t --> (f::'A => nat) x = (g::'A => nat) x) &
-(ALL x::'A. x : s & x ~: t --> f x = (0::nat))
-==> nsum s f = nsum t g"
-  by (import hollight NSUM_EQ_SUPERSET)
-
-lemma NSUM_RESTRICT_SET: "nsum
- {u::'A. EX xb::'A. (xb : (xa::'A => bool) & (x::'A => bool) xb) & u = xb}
- (xb::'A => nat) =
-nsum xa (%xa::'A. if x xa then xb xa else (0::nat))"
-  by (import hollight NSUM_RESTRICT_SET)
-
-lemma NSUM_NSUM_RESTRICT: "finite (s::'q_65257 => bool) & finite (t::'q_65256 => bool)
-==> nsum s
-     (%x::'q_65257.
-         nsum
-          {u::'q_65256.
-           EX y::'q_65256.
-              (y : t & (R::'q_65257 => 'q_65256 => bool) x y) & u = y}
-          ((f::'q_65257 => 'q_65256 => nat) x)) =
-    nsum t
-     (%y::'q_65256.
-         nsum {u::'q_65257. EX x::'q_65257. (x : s & R x y) & u = x}
-          (%x::'q_65257. f x y))"
-  by (import hollight NSUM_NSUM_RESTRICT)
-
-lemma CARD_EQ_NSUM: "finite (x::'q_65276 => bool) ==> CARD x = nsum x (%x::'q_65276. 1::nat)"
-  by (import hollight CARD_EQ_NSUM)
-
-lemma NSUM_MULTICOUNT_GEN: "finite (s::'A => bool) &
-finite (t::'B => bool) &
-(ALL j::'B.
-    j : t -->
-    CARD {u::'A. EX i::'A. (i : s & (R::'A => 'B => bool) i j) & u = i} =
-    (k::'B => nat) j)
-==> nsum s (%i::'A. CARD {u::'B. EX j::'B. (j : t & R i j) & u = j}) =
-    nsum t k"
-  by (import hollight NSUM_MULTICOUNT_GEN)
-
-lemma NSUM_MULTICOUNT: "finite (s::'A => bool) &
-finite (t::'B => bool) &
-(ALL j::'B.
-    j : t -->
-    CARD {u::'A. EX i::'A. (i : s & (R::'A => 'B => bool) i j) & u = i} =
-    (k::nat))
-==> nsum s (%i::'A. CARD {u::'B. EX j::'B. (j : t & R i j) & u = j}) =
-    k * CARD t"
-  by (import hollight NSUM_MULTICOUNT)
-
-lemma NSUM_IMAGE_GEN: "finite (s::'A => bool)
-==> nsum s (g::'A => nat) =
-    nsum ((f::'A => 'B) ` s)
-     (%y::'B. nsum {u::'A. EX x::'A. (x : s & f x = y) & u = x} g)"
-  by (import hollight NSUM_IMAGE_GEN)
-
-lemma NSUM_GROUP: "finite (s::'A => bool) & (f::'A => 'B) ` s <= (t::'B => bool)
-==> nsum t
-     (%y::'B.
-         nsum {u::'A. EX x::'A. (x : s & f x = y) & u = x} (g::'A => nat)) =
-    nsum s g"
-  by (import hollight NSUM_GROUP)
-
-lemma NSUM_SUBSET: "finite (u::'A => bool) &
-finite (v::'A => bool) &
-(ALL x::'A. x : u - v --> (f::'A => nat) x = (0::nat))
-==> nsum u f <= nsum v f"
-  by (import hollight NSUM_SUBSET)
-
-lemma NSUM_SUBSET_SIMPLE: "finite (v::'q_65804 => bool) & (u::'q_65804 => bool) <= v
-==> nsum u (f::'q_65804 => nat) <= nsum v f"
-  by (import hollight NSUM_SUBSET_SIMPLE)
-
-lemma NSUM_IMAGE_NONZERO: "finite (xb::'A => bool) &
-(ALL (xc::'A) xd::'A.
-    xc : xb & xd : xb & xc ~= xd & (xa::'A => 'B) xc = xa xd -->
-    (x::'B => nat) (xa xc) = (0::nat))
-==> nsum (xa ` xb) x = nsum xb (x o xa)"
-  by (import hollight NSUM_IMAGE_NONZERO)
-
-lemma NSUM_BIJECTION: "(ALL x::'A. x : (xb::'A => bool) --> (xa::'A => 'A) x : xb) &
-(ALL y::'A. y : xb --> (EX! x::'A. x : xb & xa x = y))
-==> nsum xb (x::'A => nat) = nsum xb (x o xa)"
-  by (import hollight NSUM_BIJECTION)
-
-lemma NSUM_NSUM_PRODUCT: "finite (x::'A => bool) &
-(ALL i::'A. i : x --> finite ((xa::'A => 'B => bool) i))
-==> nsum x (%x::'A. nsum (xa x) ((xb::'A => 'B => nat) x)) =
-    nsum {u::'A * 'B. EX (i::'A) j::'B. (i : x & j : xa i) & u = (i, j)}
-     (SOME f::'A * 'B => nat. ALL (i::'A) j::'B. f (i, j) = xb i j)"
-  by (import hollight NSUM_NSUM_PRODUCT)
-
-lemma NSUM_EQ_GENERAL: "(ALL y::'B.
-    y : (xa::'B => bool) -->
-    (EX! xa::'A. xa : (x::'A => bool) & (xd::'A => 'B) xa = y)) &
-(ALL xe::'A.
-    xe : x --> xd xe : xa & (xc::'B => nat) (xd xe) = (xb::'A => nat) xe)
-==> nsum x xb = nsum xa xc"
-  by (import hollight NSUM_EQ_GENERAL)
-
-lemma NSUM_EQ_GENERAL_INVERSES: "(ALL y::'B.
-    y : (xa::'B => bool) -->
-    (xe::'B => 'A) y : (x::'A => bool) & (xd::'A => 'B) (xe y) = y) &
-(ALL xf::'A.
-    xf : x -->
-    xd xf : xa &
-    xe (xd xf) = xf & (xc::'B => nat) (xd xf) = (xb::'A => nat) xf)
-==> nsum x xb = nsum xa xc"
-  by (import hollight NSUM_EQ_GENERAL_INVERSES)
-
-lemma NSUM_INJECTION: "finite (xb::'q_66274 => bool) &
-(ALL x::'q_66274. x : xb --> (xa::'q_66274 => 'q_66274) x : xb) &
-(ALL (x::'q_66274) y::'q_66274. x : xb & y : xb & xa x = xa y --> x = y)
-==> nsum xb ((x::'q_66274 => nat) o xa) = nsum xb x"
-  by (import hollight NSUM_INJECTION)
-
-lemma NSUM_UNION_NONZERO: "finite (xa::'q_66317 => bool) &
-finite (xb::'q_66317 => bool) &
-(ALL xc::'q_66317. xc : xa Int xb --> (x::'q_66317 => nat) xc = (0::nat))
-==> nsum (xa Un xb) x = nsum xa x + nsum xb x"
-  by (import hollight NSUM_UNION_NONZERO)
-
-lemma NSUM_UNIONS_NONZERO: "finite (x::('A => bool) => bool) &
-(ALL t::'A => bool. t : x --> finite t) &
-(ALL (t1::'A => bool) (t2::'A => bool) xa::'A.
-    t1 : x & t2 : x & t1 ~= t2 & xa : t1 & xa : t2 -->
-    (f::'A => nat) xa = (0::nat))
-==> nsum (Union x) f = nsum x (%t::'A => bool. nsum t f)"
-  by (import hollight NSUM_UNIONS_NONZERO)
-
-lemma NSUM_CASES: "finite (x::'A => bool)
-==> nsum x
-     (%x::'A.
-         if (xa::'A => bool) x then (xb::'A => nat) x
-         else (xc::'A => nat) x) =
-    nsum {u::'A. EX xb::'A. (xb : x & xa xb) & u = xb} xb +
-    nsum {u::'A. EX xb::'A. (xb : x & ~ xa xb) & u = xb} xc"
-  by (import hollight NSUM_CASES)
-
-lemma NSUM_CLOSED: "(P::nat => bool) (0::nat) &
-(ALL (x::nat) y::nat. P x & P y --> P (x + y)) &
-(ALL a::'A. a : (s::'A => bool) --> P ((f::'A => nat) a))
-==> P (nsum s f)"
-  by (import hollight NSUM_CLOSED)
-
-lemma NSUM_ADD_NUMSEG: "nsum {xb::nat..xc::nat} (%i::nat. (x::nat => nat) i + (xa::nat => nat) i) =
-nsum {xb..xc} x + nsum {xb..xc} xa"
-  by (import hollight NSUM_ADD_NUMSEG)
-
-lemma NSUM_LE_NUMSEG: "(!!i::nat.
-    (xb::nat) <= i & i <= (xc::nat)
-    ==> (x::nat => nat) i <= (xa::nat => nat) i)
-==> nsum {xb..xc} x <= nsum {xb..xc} xa"
-  by (import hollight NSUM_LE_NUMSEG)
-
-lemma NSUM_EQ_NUMSEG: "(!!i::nat.
-    (m::nat) <= i & i <= (n::nat) ==> (f::nat => nat) i = (g::nat => nat) i)
-==> nsum {m..n} f = nsum {m..n} g"
-  by (import hollight NSUM_EQ_NUMSEG)
-
-lemma NSUM_CONST_NUMSEG: "nsum {xa..xb} (%n. x) = (xb + 1 - xa) * x"
-  by (import hollight NSUM_CONST_NUMSEG)
-
-lemma NSUM_EQ_0_NUMSEG: "(!!i::nat. (m::nat) <= i & i <= (n::nat) ==> (x::nat => nat) i = (0::nat))
-==> nsum {m..n} x = (0::nat)"
-  by (import hollight NSUM_EQ_0_NUMSEG)
-
-lemma NSUM_EQ_0_IFF_NUMSEG: "(nsum {xa::nat..xb::nat} (x::nat => nat) = (0::nat)) =
-(ALL i::nat. xa <= i & i <= xb --> x i = (0::nat))"
-  by (import hollight NSUM_EQ_0_IFF_NUMSEG)
-
-lemma NSUM_TRIV_NUMSEG: "(n::nat) < (m::nat) ==> nsum {m..n} (f::nat => nat) = (0::nat)"
-  by (import hollight NSUM_TRIV_NUMSEG)
-
-lemma NSUM_SING_NUMSEG: "nsum {xa::nat..xa} (x::nat => nat) = x xa"
-  by (import hollight NSUM_SING_NUMSEG)
-
-lemma NSUM_CLAUSES_NUMSEG: "(ALL m. nsum {m..0} f = (if m = 0 then f 0 else 0)) &
-(ALL m n.
-    nsum {m..Suc n} f =
-    (if m <= Suc n then nsum {m..n} f + f (Suc n) else nsum {m..n} f))"
-  by (import hollight NSUM_CLAUSES_NUMSEG)
-
-lemma NSUM_SWAP_NUMSEG: "nsum {a::nat..b::nat}
- (%i::nat. nsum {c::nat..d::nat} ((f::nat => nat => nat) i)) =
-nsum {c..d} (%j::nat. nsum {a..b} (%i::nat. f i j))"
-  by (import hollight NSUM_SWAP_NUMSEG)
-
-lemma NSUM_ADD_SPLIT: "(xa::nat) <= (xb::nat) + (1::nat)
-==> nsum {xa..xb + (xc::nat)} (x::nat => nat) =
-    nsum {xa..xb} x + nsum {xb + (1::nat)..xb + xc} x"
-  by (import hollight NSUM_ADD_SPLIT)
-
-lemma NSUM_OFFSET: "nsum {(xb::nat) + (x::nat)..(xc::nat) + x} (xa::nat => nat) =
-nsum {xb..xc} (%i::nat. xa (i + x))"
-  by (import hollight NSUM_OFFSET)
-
-lemma NSUM_OFFSET_0: "(xa::nat) <= (xb::nat)
-==> nsum {xa..xb} (x::nat => nat) =
-    nsum {0::nat..xb - xa} (%i::nat. x (i + xa))"
-  by (import hollight NSUM_OFFSET_0)
-
-lemma NSUM_CLAUSES_LEFT: "(xa::nat) <= (xb::nat)
-==> nsum {xa..xb} (x::nat => nat) = x xa + nsum {xa + (1::nat)..xb} x"
-  by (import hollight NSUM_CLAUSES_LEFT)
-
-lemma NSUM_CLAUSES_RIGHT: "(0::nat) < (n::nat) & (m::nat) <= n
-==> nsum {m..n} (f::nat => nat) = nsum {m..n - (1::nat)} f + f n"
-  by (import hollight NSUM_CLAUSES_RIGHT)
-
-lemma NSUM_PAIR: "nsum {(2::nat) * (m::nat)..(2::nat) * (n::nat) + (1::nat)} (f::nat => nat) =
-nsum {m..n} (%i::nat. f ((2::nat) * i) + f ((2::nat) * i + (1::nat)))"
-  by (import hollight NSUM_PAIR)
-
-lemma CARD_UNIONS: "finite (x::('A => bool) => bool) &
-(ALL t::'A => bool. t : x --> finite t) &
-(ALL (t::'A => bool) u::'A => bool. t : x & u : x & t ~= u --> t Int u = {})
-==> CARD (Union x) = nsum x CARD"
-  by (import hollight CARD_UNIONS)
-
-consts
-  sum :: "('q_67488 => bool) => ('q_67488 => hollight.real) => hollight.real" 
-
-defs
-  sum_def: "(op ==::(('q_67488::type => bool)
-         => ('q_67488::type => hollight.real) => hollight.real)
-        => (('q_67488::type => bool)
-            => ('q_67488::type => hollight.real) => hollight.real)
-           => prop)
- (hollight.sum::('q_67488::type => bool)
-                => ('q_67488::type => hollight.real) => hollight.real)
- ((iterate::(hollight.real => hollight.real => hollight.real)
-            => ('q_67488::type => bool)
-               => ('q_67488::type => hollight.real) => hollight.real)
-   (real_add::hollight.real => hollight.real => hollight.real))"
-
-lemma DEF_sum: "(op =::(('q_67488::type => bool)
-        => ('q_67488::type => hollight.real) => hollight.real)
-       => (('q_67488::type => bool)
-           => ('q_67488::type => hollight.real) => hollight.real)
-          => bool)
- (hollight.sum::('q_67488::type => bool)
-                => ('q_67488::type => hollight.real) => hollight.real)
- ((iterate::(hollight.real => hollight.real => hollight.real)
-            => ('q_67488::type => bool)
-               => ('q_67488::type => hollight.real) => hollight.real)
-   (real_add::hollight.real => hollight.real => hollight.real))"
-  by (import hollight DEF_sum)
-
-lemma NEUTRAL_REAL_ADD: "neutral real_add = real_of_num 0"
-  by (import hollight NEUTRAL_REAL_ADD)
-
-lemma NEUTRAL_REAL_MUL: "neutral real_mul = real_of_num 1"
-  by (import hollight NEUTRAL_REAL_MUL)
-
-lemma MONOIDAL_REAL_ADD: "monoidal real_add"
-  by (import hollight MONOIDAL_REAL_ADD)
-
-lemma MONOIDAL_REAL_MUL: "monoidal real_mul"
-  by (import hollight MONOIDAL_REAL_MUL)
-
-lemma SUM_CLAUSES: "(ALL x::'q_67530 => hollight.real.
-    hollight.sum {} x = real_of_num (0::nat)) &
-(ALL (x::'q_67571) (xa::'q_67571 => hollight.real) xb::'q_67571 => bool.
-    finite xb -->
-    hollight.sum (insert x xb) xa =
-    (if x : xb then hollight.sum xb xa
-     else real_add (xa x) (hollight.sum xb xa)))"
-  by (import hollight SUM_CLAUSES)
-
-lemma SUM_UNION: "finite (xa::'q_67597 => bool) &
-finite (xb::'q_67597 => bool) & xa Int xb = {}
-==> hollight.sum (xa Un xb) (x::'q_67597 => hollight.real) =
-    real_add (hollight.sum xa x) (hollight.sum xb x)"
-  by (import hollight SUM_UNION)
-
-lemma SUM_DIFF: "finite (xa::'q_67637 => bool) & (xb::'q_67637 => bool) <= xa
-==> hollight.sum (xa - xb) (x::'q_67637 => hollight.real) =
-    real_sub (hollight.sum xa x) (hollight.sum xb x)"
-  by (import hollight SUM_DIFF)
-
-lemma SUM_INCL_EXCL: "finite (x::'A => bool) & finite (xa::'A => bool)
-==> real_add (hollight.sum x (xb::'A => hollight.real))
-     (hollight.sum xa xb) =
-    real_add (hollight.sum (x Un xa) xb) (hollight.sum (x Int xa) xb)"
-  by (import hollight SUM_INCL_EXCL)
-
-lemma SUM_SUPPORT: "hollight.sum
- (support real_add (x::'q_67726 => hollight.real) (xa::'q_67726 => bool))
- x =
-hollight.sum xa x"
-  by (import hollight SUM_SUPPORT)
-
-lemma SUM_ADD: "finite (xb::'q_67760 => bool)
-==> hollight.sum xb
-     (%xb::'q_67760.
-         real_add ((x::'q_67760 => hollight.real) xb)
-          ((xa::'q_67760 => hollight.real) xb)) =
-    real_add (hollight.sum xb x) (hollight.sum xb xa)"
-  by (import hollight SUM_ADD)
-
-lemma SUM_ADD_GEN: "finite
- {xa::'q_67851.
-  EX xc::'q_67851.
-     (xc : (xb::'q_67851 => bool) &
-      (x::'q_67851 => hollight.real) xc ~= real_of_num (0::nat)) &
-     xa = xc} &
-finite
- {x::'q_67851.
-  EX xc::'q_67851.
-     (xc : xb &
-      (xa::'q_67851 => hollight.real) xc ~= real_of_num (0::nat)) &
-     x = xc}
-==> hollight.sum xb (%xb::'q_67851. real_add (x xb) (xa xb)) =
-    real_add (hollight.sum xb x) (hollight.sum xb xa)"
-  by (import hollight SUM_ADD_GEN)
-
-lemma SUM_EQ_0: "(!!xb::'A.
-    xb : (xa::'A => bool)
-    ==> (x::'A => hollight.real) xb = real_of_num (0::nat))
-==> hollight.sum xa x = real_of_num (0::nat)"
-  by (import hollight SUM_EQ_0)
-
-lemma SUM_0: "hollight.sum (x::'A => bool) (%n::'A. real_of_num (0::nat)) =
-real_of_num (0::nat)"
-  by (import hollight SUM_0)
-
-lemma SUM_LMUL: "hollight.sum (s::'A => bool)
- (%x::'A. real_mul (c::hollight.real) ((f::'A => hollight.real) x)) =
-real_mul c (hollight.sum s f)"
-  by (import hollight SUM_LMUL)
-
-lemma SUM_RMUL: "hollight.sum (xb::'A => bool)
- (%xb::'A. real_mul ((x::'A => hollight.real) xb) (xa::hollight.real)) =
-real_mul (hollight.sum xb x) xa"
-  by (import hollight SUM_RMUL)
-
-lemma SUM_NEG: "hollight.sum (xa::'q_68051 => bool)
- (%xa::'q_68051. real_neg ((x::'q_68051 => hollight.real) xa)) =
-real_neg (hollight.sum xa x)"
-  by (import hollight SUM_NEG)
-
-lemma SUM_SUB: "finite (xb::'q_68086 => bool)
-==> hollight.sum xb
-     (%xb::'q_68086.
-         real_sub ((x::'q_68086 => hollight.real) xb)
-          ((xa::'q_68086 => hollight.real) xb)) =
-    real_sub (hollight.sum xb x) (hollight.sum xb xa)"
-  by (import hollight SUM_SUB)
-
-lemma SUM_LE: "finite (xb::'q_68128 => bool) &
-(ALL xc::'q_68128.
-    xc : xb -->
-    real_le ((x::'q_68128 => hollight.real) xc)
-     ((xa::'q_68128 => hollight.real) xc))
-==> real_le (hollight.sum xb x) (hollight.sum xb xa)"
-  by (import hollight SUM_LE)
-
-lemma SUM_LT: "finite (s::'A => bool) &
-(ALL x::'A.
-    x : s -->
-    real_le ((f::'A => hollight.real) x) ((g::'A => hollight.real) x)) &
-(EX x::'A. x : s & real_lt (f x) (g x))
-==> real_lt (hollight.sum s f) (hollight.sum s g)"
-  by (import hollight SUM_LT)
-
-lemma SUM_LT_ALL: "finite (s::'q_68250 => bool) &
-s ~= {} &
-(ALL x::'q_68250.
-    x : s -->
-    real_lt ((f::'q_68250 => hollight.real) x)
-     ((g::'q_68250 => hollight.real) x))
-==> real_lt (hollight.sum s f) (hollight.sum s g)"
-  by (import hollight SUM_LT_ALL)
-
-lemma SUM_EQ: "(!!xc::'q_68288.
-    xc : (xb::'q_68288 => bool)
-    ==> (x::'q_68288 => hollight.real) xc =
-        (xa::'q_68288 => hollight.real) xc)
-==> hollight.sum xb x = hollight.sum xb xa"
-  by (import hollight SUM_EQ)
-
-lemma SUM_ABS: "finite (s::'q_68347 => bool)
-==> real_le (real_abs (hollight.sum s (f::'q_68347 => hollight.real)))
-     (hollight.sum s (%x::'q_68347. real_abs (f x)))"
-  by (import hollight SUM_ABS)
-
-lemma SUM_ABS_LE: "finite (s::'A => bool) &
-(ALL x::'A.
-    x : s -->
-    real_le (real_abs ((f::'A => hollight.real) x))
-     ((g::'A => hollight.real) x))
-==> real_le (real_abs (hollight.sum s f)) (hollight.sum s g)"
-  by (import hollight SUM_ABS_LE)
-
-lemma SUM_CONST: "finite (s::'q_68423 => bool)
-==> hollight.sum s (%n::'q_68423. c::hollight.real) =
-    real_mul (real_of_num (CARD s)) c"
-  by (import hollight SUM_CONST)
-
-lemma SUM_POS_LE: "finite (xa::'q_68465 => bool) &
-(ALL xb::'q_68465.
-    xb : xa -->
-    real_le (real_of_num (0::nat)) ((x::'q_68465 => hollight.real) xb))
-==> real_le (real_of_num (0::nat)) (hollight.sum xa x)"
-  by (import hollight SUM_POS_LE)
-
-lemma SUM_POS_BOUND: "[| finite (x::'A => bool) &
-   (ALL xa::'A.
-       xa : x -->
-       real_le (real_of_num (0::nat)) ((f::'A => hollight.real) xa)) &
-   real_le (hollight.sum x f) (b::hollight.real);
-   (xa::'A) : x |]
-==> real_le (f xa) b"
-  by (import hollight SUM_POS_BOUND)
-
-lemma SUM_POS_EQ_0: "[| finite (xa::'q_68612 => bool) &
-   (ALL xb::'q_68612.
-       xb : xa -->
-       real_le (real_of_num (0::nat)) ((x::'q_68612 => hollight.real) xb)) &
-   hollight.sum xa x = real_of_num (0::nat);
-   (xb::'q_68612) : xa |]
-==> x xb = real_of_num (0::nat)"
-  by (import hollight SUM_POS_EQ_0)
-
-lemma SUM_ZERO_EXISTS: "finite (s::'A => bool) &
-hollight.sum s (u::'A => hollight.real) = real_of_num (0::nat)
-==> (ALL i::'A. i : s --> u i = real_of_num (0::nat)) |
-    (EX (j::'A) k::'A.
-        j : s &
-        real_lt (u j) (real_of_num (0::nat)) &
-        k : s & real_gt (u k) (real_of_num (0::nat)))"
-  by (import hollight SUM_ZERO_EXISTS)
-
-lemma SUM_DELETE: "finite (xa::'q_68854 => bool) & (xb::'q_68854) : xa
-==> hollight.sum (xa - {xb}) (x::'q_68854 => hollight.real) =
-    real_sub (hollight.sum xa x) (x xb)"
-  by (import hollight SUM_DELETE)
-
-lemma SUM_DELETE_CASES: "finite (s::'q_68907 => bool)
-==> hollight.sum (s - {a::'q_68907}) (f::'q_68907 => hollight.real) =
-    (if a : s then real_sub (hollight.sum s f) (f a) else hollight.sum s f)"
-  by (import hollight SUM_DELETE_CASES)
-
-lemma SUM_SING: "hollight.sum {xa::'q_68930} (x::'q_68930 => hollight.real) = x xa"
-  by (import hollight SUM_SING)
-
-lemma SUM_DELTA: "hollight.sum (x::'A => bool)
- (%x::'A. if x = (xa::'A) then b::hollight.real else real_of_num (0::nat)) =
-(if xa : x then b else real_of_num (0::nat))"
-  by (import hollight SUM_DELTA)
-
-lemma SUM_SWAP: "finite (x::'A => bool) & finite (xa::'B => bool)
-==> hollight.sum x
-     (%i::'A. hollight.sum xa ((f::'A => 'B => hollight.real) i)) =
-    hollight.sum xa (%j::'B. hollight.sum x (%i::'A. f i j))"
-  by (import hollight SUM_SWAP)
-
-lemma SUM_IMAGE: "(!!(xa::'q_69070) y::'q_69070.
-    xa : (xb::'q_69070 => bool) &
-    y : xb & (x::'q_69070 => 'q_69046) xa = x y
-    ==> xa = y)
-==> hollight.sum (x ` xb) (xa::'q_69046 => hollight.real) =
-    hollight.sum xb (xa o x)"
-  by (import hollight SUM_IMAGE)
-
-lemma SUM_SUPERSET: "(xa::'A => bool) <= (xb::'A => bool) &
-(ALL xc::'A.
-    xc : xb & xc ~: xa -->
-    (x::'A => hollight.real) xc = real_of_num (0::nat))
-==> hollight.sum xb x = hollight.sum xa x"
-  by (import hollight SUM_SUPERSET)
-
-lemma SUM_UNION_RZERO: "finite (u::'A => bool) &
-(ALL x::'A.
-    x : (v::'A => bool) & x ~: u -->
-    (f::'A => hollight.real) x = real_of_num (0::nat))
-==> hollight.sum (u Un v) f = hollight.sum u f"
-  by (import hollight SUM_UNION_RZERO)
-
-lemma SUM_UNION_LZERO: "finite (v::'A => bool) &
-(ALL x::'A.
-    x : (u::'A => bool) & x ~: v -->
-    (f::'A => hollight.real) x = real_of_num (0::nat))
-==> hollight.sum (u Un v) f = hollight.sum v f"
-  by (import hollight SUM_UNION_LZERO)
-
-lemma SUM_RESTRICT: "finite (s::'q_69267 => bool)
-==> hollight.sum s
-     (%x::'q_69267.
-         if x : s then (f::'q_69267 => hollight.real) x
-         else real_of_num (0::nat)) =
-    hollight.sum s f"
-  by (import hollight SUM_RESTRICT)
-
-lemma SUM_BOUND: "finite (x::'A => bool) &
-(ALL xc::'A.
-    xc : x --> real_le ((xa::'A => hollight.real) xc) (xb::hollight.real))
-==> real_le (hollight.sum x xa) (real_mul (real_of_num (CARD x)) xb)"
-  by (import hollight SUM_BOUND)
-
-lemma SUM_BOUND_GEN: "finite (s::'A => bool) &
-s ~= {} &
-(ALL x::'A.
-    x : s -->
-    real_le ((f::'A => hollight.real) x)
-     (real_div (b::hollight.real) (real_of_num (CARD s))))
-==> real_le (hollight.sum s f) b"
-  by (import hollight SUM_BOUND_GEN)
-
-lemma SUM_ABS_BOUND: "finite (s::'A => bool) &
-(ALL x::'A.
-    x : s -->
-    real_le (real_abs ((f::'A => hollight.real) x)) (b::hollight.real))
-==> real_le (real_abs (hollight.sum s f))
-     (real_mul (real_of_num (CARD s)) b)"
-  by (import hollight SUM_ABS_BOUND)
-
-lemma SUM_BOUND_LT: "finite (s::'A => bool) &
-(ALL x::'A.
-    x : s --> real_le ((f::'A => hollight.real) x) (b::hollight.real)) &
-(EX x::'A. x : s & real_lt (f x) b)
-==> real_lt (hollight.sum s f) (real_mul (real_of_num (CARD s)) b)"
-  by (import hollight SUM_BOUND_LT)
-
-lemma SUM_BOUND_LT_ALL: "finite (s::'q_69531 => bool) &
-s ~= {} &
-(ALL x::'q_69531.
-    x : s --> real_lt ((f::'q_69531 => hollight.real) x) (b::hollight.real))
-==> real_lt (hollight.sum s f) (real_mul (real_of_num (CARD s)) b)"
-  by (import hollight SUM_BOUND_LT_ALL)
-
-lemma SUM_BOUND_LT_GEN: "finite (s::'A => bool) &
-s ~= {} &
-(ALL x::'A.
-    x : s -->
-    real_lt ((f::'A => hollight.real) x)
-     (real_div (b::hollight.real) (real_of_num (CARD s))))
-==> real_lt (hollight.sum s f) b"
-  by (import hollight SUM_BOUND_LT_GEN)
-
-lemma SUM_UNION_EQ: "finite (u::'q_69614 => bool) &
-(s::'q_69614 => bool) Int (t::'q_69614 => bool) = {} & s Un t = u
-==> real_add (hollight.sum s (f::'q_69614 => hollight.real))
-     (hollight.sum t f) =
-    hollight.sum u f"
-  by (import hollight SUM_UNION_EQ)
-
-lemma SUM_EQ_SUPERSET: "finite (t::'A => bool) &
-t <= (s::'A => bool) &
-(ALL x::'A.
-    x : t --> (f::'A => hollight.real) x = (g::'A => hollight.real) x) &
-(ALL x::'A. x : s & x ~: t --> f x = real_of_num (0::nat))
-==> hollight.sum s f = hollight.sum t g"
-  by (import hollight SUM_EQ_SUPERSET)
-
-lemma SUM_RESTRICT_SET: "hollight.sum
- {u::'q_69783.
-  EX xb::'q_69783.
-     (xb : (xa::'q_69783 => bool) & (x::'q_69783 => bool) xb) & u = xb}
- (xb::'q_69783 => hollight.real) =
-hollight.sum xa
- (%xa::'q_69783. if x xa then xb xa else real_of_num (0::nat))"
-  by (import hollight SUM_RESTRICT_SET)
-
-lemma SUM_SUM_RESTRICT: "finite (s::'q_69875 => bool) & finite (t::'q_69874 => bool)
-==> hollight.sum s
-     (%x::'q_69875.
-         hollight.sum
-          {u::'q_69874.
-           EX y::'q_69874.
-              (y : t & (R::'q_69875 => 'q_69874 => bool) x y) & u = y}
-          ((f::'q_69875 => 'q_69874 => hollight.real) x)) =
-    hollight.sum t
-     (%y::'q_69874.
-         hollight.sum {u::'q_69875. EX x::'q_69875. (x : s & R x y) & u = x}
-          (%x::'q_69875. f x y))"
-  by (import hollight SUM_SUM_RESTRICT)
-
-lemma CARD_EQ_SUM: "finite (x::'q_69896 => bool)
-==> real_of_num (CARD x) =
-    hollight.sum x (%x::'q_69896. real_of_num (1::nat))"
-  by (import hollight CARD_EQ_SUM)
-
-lemma SUM_MULTICOUNT_GEN: "finite (s::'A => bool) &
-finite (t::'B => bool) &
-(ALL j::'B.
-    j : t -->
-    CARD {u::'A. EX i::'A. (i : s & (R::'A => 'B => bool) i j) & u = i} =
-    (k::'B => nat) j)
-==> hollight.sum s
-     (%i::'A.
-         real_of_num (CARD {u::'B. EX j::'B. (j : t & R i j) & u = j})) =
-    hollight.sum t (%i::'B. real_of_num (k i))"
-  by (import hollight SUM_MULTICOUNT_GEN)
-
-lemma SUM_MULTICOUNT: "finite (s::'A => bool) &
-finite (t::'B => bool) &
-(ALL j::'B.
-    j : t -->
-    CARD {u::'A. EX i::'A. (i : s & (R::'A => 'B => bool) i j) & u = i} =
-    (k::nat))
-==> hollight.sum s
-     (%i::'A.
-         real_of_num (CARD {u::'B. EX j::'B. (j : t & R i j) & u = j})) =
-    real_of_num (k * CARD t)"
-  by (import hollight SUM_MULTICOUNT)
-
-lemma SUM_IMAGE_GEN: "finite (s::'A => bool)
-==> hollight.sum s (g::'A => hollight.real) =
-    hollight.sum ((f::'A => 'B) ` s)
-     (%y::'B. hollight.sum {u::'A. EX x::'A. (x : s & f x = y) & u = x} g)"
-  by (import hollight SUM_IMAGE_GEN)
-
-lemma SUM_GROUP: "finite (s::'A => bool) & (f::'A => 'B) ` s <= (t::'B => bool)
-==> hollight.sum t
-     (%y::'B.
-         hollight.sum {u::'A. EX x::'A. (x : s & f x = y) & u = x}
-          (g::'A => hollight.real)) =
-    hollight.sum s g"
-  by (import hollight SUM_GROUP)
-
-lemma REAL_OF_NUM_SUM: "finite (s::'q_70361 => bool)
-==> real_of_num (nsum s (f::'q_70361 => nat)) =
-    hollight.sum s (%x::'q_70361. real_of_num (f x))"
-  by (import hollight REAL_OF_NUM_SUM)
-
-lemma SUM_SUBSET: "finite (u::'A => bool) &
-finite (v::'A => bool) &
-(ALL x::'A.
-    x : u - v -->
-    real_le ((f::'A => hollight.real) x) (real_of_num (0::nat))) &
-(ALL x::'A. x : v - u --> real_le (real_of_num (0::nat)) (f x))
-==> real_le (hollight.sum u f) (hollight.sum v f)"
-  by (import hollight SUM_SUBSET)
-
-lemma SUM_SUBSET_SIMPLE: "finite (v::'A => bool) &
-(u::'A => bool) <= v &
-(ALL x::'A.
-    x : v - u -->
-    real_le (real_of_num (0::nat)) ((f::'A => hollight.real) x))
-==> real_le (hollight.sum u f) (hollight.sum v f)"
-  by (import hollight SUM_SUBSET_SIMPLE)
-
-lemma SUM_IMAGE_NONZERO: "finite (xb::'A => bool) &
-(ALL (xc::'A) xd::'A.
-    xc : xb & xd : xb & xc ~= xd & (xa::'A => 'B) xc = xa xd -->
-    (x::'B => hollight.real) (xa xc) = real_of_num (0::nat))
-==> hollight.sum (xa ` xb) x = hollight.sum xb (x o xa)"
-  by (import hollight SUM_IMAGE_NONZERO)
-
-lemma SUM_BIJECTION: "(ALL x::'A. x : (xb::'A => bool) --> (xa::'A => 'A) x : xb) &
-(ALL y::'A. y : xb --> (EX! x::'A. x : xb & xa x = y))
-==> hollight.sum xb (x::'A => hollight.real) = hollight.sum xb (x o xa)"
-  by (import hollight SUM_BIJECTION)
-
-lemma SUM_SUM_PRODUCT: "finite (x::'A => bool) &
-(ALL i::'A. i : x --> finite ((xa::'A => 'B => bool) i))
-==> hollight.sum x
-     (%x::'A. hollight.sum (xa x) ((xb::'A => 'B => hollight.real) x)) =
-    hollight.sum
-     {u::'A * 'B. EX (i::'A) j::'B. (i : x & j : xa i) & u = (i, j)}
-     (SOME f::'A * 'B => hollight.real.
-         ALL (i::'A) j::'B. f (i, j) = xb i j)"
-  by (import hollight SUM_SUM_PRODUCT)
-
-lemma SUM_EQ_GENERAL: "(ALL y::'B.
-    y : (xa::'B => bool) -->
-    (EX! xa::'A. xa : (x::'A => bool) & (xd::'A => 'B) xa = y)) &
-(ALL xe::'A.
-    xe : x -->
-    xd xe : xa &
-    (xc::'B => hollight.real) (xd xe) = (xb::'A => hollight.real) xe)
-==> hollight.sum x xb = hollight.sum xa xc"
-  by (import hollight SUM_EQ_GENERAL)
-
-lemma SUM_EQ_GENERAL_INVERSES: "(ALL y::'B.
-    y : (xa::'B => bool) -->
-    (xe::'B => 'A) y : (x::'A => bool) & (xd::'A => 'B) (xe y) = y) &
-(ALL xf::'A.
-    xf : x -->
-    xd xf : xa &
-    xe (xd xf) = xf &
-    (xc::'B => hollight.real) (xd xf) = (xb::'A => hollight.real) xf)
-==> hollight.sum x xb = hollight.sum xa xc"
-  by (import hollight SUM_EQ_GENERAL_INVERSES)
-
-lemma SUM_INJECTION: "finite (xb::'q_71007 => bool) &
-(ALL x::'q_71007. x : xb --> (xa::'q_71007 => 'q_71007) x : xb) &
-(ALL (x::'q_71007) y::'q_71007. x : xb & y : xb & xa x = xa y --> x = y)
-==> hollight.sum xb ((x::'q_71007 => hollight.real) o xa) =
-    hollight.sum xb x"
-  by (import hollight SUM_INJECTION)
-
-lemma SUM_UNION_NONZERO: "finite (xa::'q_71050 => bool) &
-finite (xb::'q_71050 => bool) &
-(ALL xc::'q_71050.
-    xc : xa Int xb -->
-    (x::'q_71050 => hollight.real) xc = real_of_num (0::nat))
-==> hollight.sum (xa Un xb) x =
-    real_add (hollight.sum xa x) (hollight.sum xb x)"
-  by (import hollight SUM_UNION_NONZERO)
-
-lemma SUM_UNIONS_NONZERO: "finite (x::('A => bool) => bool) &
-(ALL t::'A => bool. t : x --> finite t) &
-(ALL (t1::'A => bool) (t2::'A => bool) xa::'A.
-    t1 : x & t2 : x & t1 ~= t2 & xa : t1 & xa : t2 -->
-    (f::'A => hollight.real) xa = real_of_num (0::nat))
-==> hollight.sum (Union x) f =
-    hollight.sum x (%t::'A => bool. hollight.sum t f)"
-  by (import hollight SUM_UNIONS_NONZERO)
-
-lemma SUM_CASES: "finite (x::'A => bool)
-==> hollight.sum x
-     (%x::'A.
-         if (xa::'A => bool) x then (xb::'A => hollight.real) x
-         else (xc::'A => hollight.real) x) =
-    real_add (hollight.sum {u::'A. EX xb::'A. (xb : x & xa xb) & u = xb} xb)
-     (hollight.sum {u::'A. EX xb::'A. (xb : x & ~ xa xb) & u = xb} xc)"
-  by (import hollight SUM_CASES)
-
-lemma SUM_CASES_1: "finite (s::'q_71319 => bool) & (a::'q_71319) : s
-==> hollight.sum s
-     (%x::'q_71319.
-         if x = a then y::hollight.real
-         else (f::'q_71319 => hollight.real) x) =
-    real_add (hollight.sum s f) (real_sub y (f a))"
-  by (import hollight SUM_CASES_1)
-
-lemma SUM_LE_INCLUDED: "finite (s::'A => bool) &
-finite (t::'B => bool) &
-(ALL y::'B.
-    y : t --> real_le (real_of_num (0::nat)) ((g::'B => hollight.real) y)) &
-(ALL x::'A.
-    x : s -->
-    (EX y::'B.
-        y : t &
-        (i::'B => 'A) y = x & real_le ((f::'A => hollight.real) x) (g y)))
-==> real_le (hollight.sum s f) (hollight.sum t g)"
-  by (import hollight SUM_LE_INCLUDED)
-
-lemma SUM_IMAGE_LE: "finite (s::'A => bool) &
-(ALL x::'A.
-    x : s -->
-    real_le (real_of_num (0::nat))
-     ((g::'B => hollight.real) ((f::'A => 'B) x)))
-==> real_le (hollight.sum (f ` s) g) (hollight.sum s (g o f))"
-  by (import hollight SUM_IMAGE_LE)
-
-lemma SUM_CLOSED: "(P::hollight.real => bool) (real_of_num (0::nat)) &
-(ALL (x::hollight.real) y::hollight.real. P x & P y --> P (real_add x y)) &
-(ALL a::'A. a : (s::'A => bool) --> P ((f::'A => hollight.real) a))
-==> P (hollight.sum s f)"
-  by (import hollight SUM_CLOSED)
-
-lemma SUM_ADD_NUMSEG: "hollight.sum {xb::nat..xc::nat}
- (%i::nat.
-     real_add ((x::nat => hollight.real) i)
-      ((xa::nat => hollight.real) i)) =
-real_add (hollight.sum {xb..xc} x) (hollight.sum {xb..xc} xa)"
-  by (import hollight SUM_ADD_NUMSEG)
-
-lemma SUM_SUB_NUMSEG: "hollight.sum {xb::nat..xc::nat}
- (%i::nat.
-     real_sub ((x::nat => hollight.real) i)
-      ((xa::nat => hollight.real) i)) =
-real_sub (hollight.sum {xb..xc} x) (hollight.sum {xb..xc} xa)"
-  by (import hollight SUM_SUB_NUMSEG)
-
-lemma SUM_LE_NUMSEG: "(!!i::nat.
-    (xb::nat) <= i & i <= (xc::nat)
-    ==> real_le ((x::nat => hollight.real) i)
-         ((xa::nat => hollight.real) i))
-==> real_le (hollight.sum {xb..xc} x) (hollight.sum {xb..xc} xa)"
-  by (import hollight SUM_LE_NUMSEG)
-
-lemma SUM_EQ_NUMSEG: "(!!i::nat.
-    (m::nat) <= i & i <= (n::nat)
-    ==> (f::nat => hollight.real) i = (g::nat => hollight.real) i)
-==> hollight.sum {m..n} f = hollight.sum {m..n} g"
-  by (import hollight SUM_EQ_NUMSEG)
-
-lemma SUM_ABS_NUMSEG: "real_le
- (real_abs (hollight.sum {xa::nat..xb::nat} (x::nat => hollight.real)))
- (hollight.sum {xa..xb} (%i::nat. real_abs (x i)))"
-  by (import hollight SUM_ABS_NUMSEG)
-
-lemma SUM_CONST_NUMSEG: "hollight.sum {xa..xb} (%n. x) = real_mul (real_of_num (xb + 1 - xa)) x"
-  by (import hollight SUM_CONST_NUMSEG)
-
-lemma SUM_EQ_0_NUMSEG: "(!!i::nat.
-    (m::nat) <= i & i <= (n::nat)
-    ==> (x::nat => hollight.real) i = real_of_num (0::nat))
-==> hollight.sum {m..n} x = real_of_num (0::nat)"
-  by (import hollight SUM_EQ_0_NUMSEG)
-
-lemma SUM_TRIV_NUMSEG: "(n::nat) < (m::nat)
-==> hollight.sum {m..n} (f::nat => hollight.real) = real_of_num (0::nat)"
-  by (import hollight SUM_TRIV_NUMSEG)
-
-lemma SUM_POS_LE_NUMSEG: "(!!p::nat.
-    (x::nat) <= p & p <= (xa::nat)
-    ==> real_le (real_of_num (0::nat)) ((xb::nat => hollight.real) p))
-==> real_le (real_of_num (0::nat)) (hollight.sum {x..xa} xb)"
-  by (import hollight SUM_POS_LE_NUMSEG)
-
-lemma SUM_POS_EQ_0_NUMSEG: "[| (ALL p::nat.
-       (m::nat) <= p & p <= (n::nat) -->
-       real_le (real_of_num (0::nat)) ((f::nat => hollight.real) p)) &
-   hollight.sum {m..n} f = real_of_num (0::nat);
-   m <= (p::nat) & p <= n |]
-==> f p = real_of_num (0::nat)"
-  by (import hollight SUM_POS_EQ_0_NUMSEG)
-
-lemma SUM_SING_NUMSEG: "hollight.sum {xa::nat..xa} (x::nat => hollight.real) = x xa"
-  by (import hollight SUM_SING_NUMSEG)
-
-lemma SUM_CLAUSES_NUMSEG: "(ALL m. hollight.sum {m..0} f = (if m = 0 then f 0 else real_of_num 0)) &
-(ALL m n.
-    hollight.sum {m..Suc n} f =
-    (if m <= Suc n then real_add (hollight.sum {m..n} f) (f (Suc n))
-     else hollight.sum {m..n} f))"
-  by (import hollight SUM_CLAUSES_NUMSEG)
-
-lemma SUM_SWAP_NUMSEG: "hollight.sum {a::nat..b::nat}
- (%i::nat.
-     hollight.sum {c::nat..d::nat} ((f::nat => nat => hollight.real) i)) =
-hollight.sum {c..d} (%j::nat. hollight.sum {a..b} (%i::nat. f i j))"
-  by (import hollight SUM_SWAP_NUMSEG)
-
-lemma SUM_ADD_SPLIT: "(xa::nat) <= (xb::nat) + (1::nat)
-==> hollight.sum {xa..xb + (xc::nat)} (x::nat => hollight.real) =
-    real_add (hollight.sum {xa..xb} x)
-     (hollight.sum {xb + (1::nat)..xb + xc} x)"
-  by (import hollight SUM_ADD_SPLIT)
-
-lemma SUM_OFFSET: "hollight.sum {(xb::nat) + (x::nat)..(xc::nat) + x}
- (xa::nat => hollight.real) =
-hollight.sum {xb..xc} (%i::nat. xa (i + x))"
-  by (import hollight SUM_OFFSET)
-
-lemma SUM_OFFSET_0: "(xa::nat) <= (xb::nat)
-==> hollight.sum {xa..xb} (x::nat => hollight.real) =
-    hollight.sum {0::nat..xb - xa} (%i::nat. x (i + xa))"
-  by (import hollight SUM_OFFSET_0)
-
-lemma SUM_CLAUSES_LEFT: "(xa::nat) <= (xb::nat)
-==> hollight.sum {xa..xb} (x::nat => hollight.real) =
-    real_add (x xa) (hollight.sum {xa + (1::nat)..xb} x)"
-  by (import hollight SUM_CLAUSES_LEFT)
-
-lemma SUM_CLAUSES_RIGHT: "(0::nat) < (n::nat) & (m::nat) <= n
-==> hollight.sum {m..n} (f::nat => hollight.real) =
-    real_add (hollight.sum {m..n - (1::nat)} f) (f n)"
-  by (import hollight SUM_CLAUSES_RIGHT)
-
-lemma SUM_PAIR: "hollight.sum {(2::nat) * (m::nat)..(2::nat) * (n::nat) + (1::nat)}
- (f::nat => hollight.real) =
-hollight.sum {m..n}
- (%i::nat. real_add (f ((2::nat) * i)) (f ((2::nat) * i + (1::nat))))"
-  by (import hollight SUM_PAIR)
-
-lemma REAL_OF_NUM_SUM_NUMSEG: "real_of_num (nsum {xa::nat..xb::nat} (x::nat => nat)) =
-hollight.sum {xa..xb} (%i::nat. real_of_num (x i))"
-  by (import hollight REAL_OF_NUM_SUM_NUMSEG)
-
-lemma SUM_PARTIAL_SUC: "hollight.sum {m::nat..n::nat}
- (%k::nat.
-     real_mul ((f::nat => hollight.real) k)
-      (real_sub ((g::nat => hollight.real) (k + (1::nat))) (g k))) =
-(if m <= n
- then real_sub
-       (real_sub (real_mul (f (n + (1::nat))) (g (n + (1::nat))))
-         (real_mul (f m) (g m)))
-       (hollight.sum {m..n}
-         (%k::nat.
-             real_mul (g (k + (1::nat)))
-              (real_sub (f (k + (1::nat))) (f k))))
- else real_of_num (0::nat))"
-  by (import hollight SUM_PARTIAL_SUC)
-
-lemma SUM_PARTIAL_PRE: "hollight.sum {m::nat..n::nat}
- (%k::nat.
-     real_mul ((f::nat => hollight.real) k)
-      (real_sub ((g::nat => hollight.real) k) (g (k - (1::nat))))) =
-(if m <= n
- then real_sub
-       (real_sub (real_mul (f (n + (1::nat))) (g n))
-         (real_mul (f m) (g (m - (1::nat)))))
-       (hollight.sum {m..n}
-         (%k::nat. real_mul (g k) (real_sub (f (k + (1::nat))) (f k))))
- else real_of_num (0::nat))"
-  by (import hollight SUM_PARTIAL_PRE)
-
-lemma SUM_DIFFS: "hollight.sum {x::nat..xa::nat}
- (%x::nat. real_sub ((f::nat => hollight.real) x) (f (x + (1::nat)))) =
-(if x <= xa then real_sub (f x) (f (xa + (1::nat)))
- else real_of_num (0::nat))"
-  by (import hollight SUM_DIFFS)
-
-lemma SUM_DIFFS_ALT: "hollight.sum {m::nat..n::nat}
- (%x::nat. real_sub ((f::nat => hollight.real) (x + (1::nat))) (f x)) =
-(if m <= n then real_sub (f (n + (1::nat))) (f m) else real_of_num (0::nat))"
-  by (import hollight SUM_DIFFS_ALT)
-
-lemma SUM_COMBINE_R: "(m::nat) <= (n::nat) + (1::nat) & n <= (p::nat)
-==> real_add (hollight.sum {m..n} (f::nat => hollight.real))
-     (hollight.sum {n + (1::nat)..p} f) =
-    hollight.sum {m..p} f"
-  by (import hollight SUM_COMBINE_R)
-
-lemma SUM_COMBINE_L: "(0::nat) < (n::nat) & (m::nat) <= n & n <= (p::nat) + (1::nat)
-==> real_add (hollight.sum {m..n - (1::nat)} (f::nat => hollight.real))
-     (hollight.sum {n..p} f) =
-    hollight.sum {m..p} f"
-  by (import hollight SUM_COMBINE_L)
-
-lemma REAL_SUB_POW: "1 <= xb
-==> real_sub (real_pow x xb) (real_pow xa xb) =
-    real_mul (real_sub x xa)
-     (hollight.sum {0..xb - 1}
-       (%i. real_mul (real_pow x i) (real_pow xa (xb - 1 - i))))"
-  by (import hollight REAL_SUB_POW)
-
-lemma REAL_SUB_POW_R1: "1 <= n
-==> real_sub (real_pow x n) (real_of_num 1) =
-    real_mul (real_sub x (real_of_num 1))
-     (hollight.sum {0..n - 1} (real_pow x))"
-  by (import hollight REAL_SUB_POW_R1)
-
-lemma REAL_SUB_POW_L1: "1 <= xa
-==> real_sub (real_of_num 1) (real_pow x xa) =
-    real_mul (real_sub (real_of_num 1) x)
-     (hollight.sum {0..xa - 1} (real_pow x))"
-  by (import hollight REAL_SUB_POW_L1)
-
-definition
-  dimindex :: "('A => bool) => nat"  where
-  "(op ==::(('A::type => bool) => nat) => (('A::type => bool) => nat) => prop)
- (dimindex::('A::type => bool) => nat)
- (%u::'A::type => bool.
-     (If::bool => nat => nat => nat)
-      ((finite::('A::type => bool) => bool) (UNIV::'A::type => bool))
-      ((CARD::('A::type => bool) => nat) (UNIV::'A::type => bool)) (1::nat))"
-
-lemma DEF_dimindex: "(op =::(('A::type => bool) => nat) => (('A::type => bool) => nat) => bool)
- (dimindex::('A::type => bool) => nat)
- (%u::'A::type => bool.
-     (If::bool => nat => nat => nat)
-      ((finite::('A::type => bool) => bool) (UNIV::'A::type => bool))
-      ((CARD::('A::type => bool) => nat) (UNIV::'A::type => bool)) (1::nat))"
-  by (import hollight DEF_dimindex)
-
-lemma DIMINDEX_NONZERO: "dimindex (s::'A => bool) ~= (0::nat)"
-  by (import hollight DIMINDEX_NONZERO)
-
-lemma DIMINDEX_GE_1: "(1::nat) <= dimindex (x::'A => bool)"
-  by (import hollight DIMINDEX_GE_1)
-
-lemma DIMINDEX_UNIV: "(op =::nat => nat => bool)
- ((dimindex::('A::type => bool) => nat) (x::'A::type => bool))
- ((dimindex::('A::type => bool) => nat) (UNIV::'A::type => bool))"
-  by (import hollight DIMINDEX_UNIV)
-
-lemma DIMINDEX_UNIQUE: "(op ==>::prop => prop => prop)
- ((Trueprop::bool => prop)
-   ((HAS_SIZE::('A::type => bool) => nat => bool) (UNIV::'A::type => bool)
-     (n::nat)))
- ((Trueprop::bool => prop)
-   ((op =::nat => nat => bool)
-     ((dimindex::('A::type => bool) => nat) (UNIV::'A::type => bool)) n))"
-  by (import hollight DIMINDEX_UNIQUE)
-
-typedef (open) ('A) finite_image = "{x::nat. x : dotdot (NUMERAL (NUMERAL_BIT1 (0::nat))) (dimindex UNIV)}"  morphisms "dest_finite_image" "finite_index"
-  apply (rule light_ex_imp_nonempty[where t="SOME x::nat. x : dotdot (NUMERAL (NUMERAL_BIT1 (0::nat))) (dimindex UNIV)"])
-  by (import hollight TYDEF_finite_image)
-
-syntax
-  dest_finite_image :: _ 
-
-syntax
-  finite_index :: _ 
-
-lemmas "TYDEF_finite_image_@intern" = typedef_hol2hollight 
-  [where a="a :: 'A finite_image" and r=r ,
-   OF type_definition_finite_image]
-
-lemma FINITE_IMAGE_IMAGE: "(op =::('A::type finite_image => bool)
-       => ('A::type finite_image => bool) => bool)
- (UNIV::'A::type finite_image => bool)
- ((op `::(nat => 'A::type finite_image)
-         => (nat => bool) => 'A::type finite_image => bool)
-   (finite_index::nat => 'A::type finite_image)
-   ((atLeastAtMost::nat => nat => nat => bool) (1::nat)
-     ((dimindex::('A::type => bool) => nat) (UNIV::'A::type => bool))))"
-  by (import hollight FINITE_IMAGE_IMAGE)
-
-lemma HAS_SIZE_FINITE_IMAGE: "(HAS_SIZE::('A::type finite_image => bool) => nat => bool)
- (UNIV::'A::type finite_image => bool)
- ((dimindex::('A::type => bool) => nat) (s::'A::type => bool))"
-  by (import hollight HAS_SIZE_FINITE_IMAGE)
-
-lemma CARD_FINITE_IMAGE: "(op =::nat => nat => bool)
- ((CARD::('A::type finite_image => bool) => nat)
-   (UNIV::'A::type finite_image => bool))
- ((dimindex::('A::type => bool) => nat) (s::'A::type => bool))"
-  by (import hollight CARD_FINITE_IMAGE)
-
-lemma FINITE_FINITE_IMAGE: "(finite::('A::type finite_image => bool) => bool)
- (UNIV::'A::type finite_image => bool)"
-  by (import hollight FINITE_FINITE_IMAGE)
-
-lemma DIMINDEX_FINITE_IMAGE: "dimindex (s::'A finite_image => bool) = dimindex (t::'A => bool)"
-  by (import hollight DIMINDEX_FINITE_IMAGE)
-
-lemma FINITE_INDEX_WORKS: "(Ex1::(nat => bool) => bool)
- (%xa::nat.
-     (op &::bool => bool => bool) ((op <=::nat => nat => bool) (1::nat) xa)
-      ((op &::bool => bool => bool)
-        ((op <=::nat => nat => bool) xa
-          ((dimindex::('A::type => bool) => nat) (UNIV::'A::type => bool)))
-        ((op =::'A::type finite_image => 'A::type finite_image => bool)
-          ((finite_index::nat => 'A::type finite_image) xa)
-          (x::'A::type finite_image))))"
-  by (import hollight FINITE_INDEX_WORKS)
-
-lemma FINITE_INDEX_INJ: "(op ==>::prop => prop => prop)
- ((Trueprop::bool => prop)
-   ((op &::bool => bool => bool)
-     ((op <=::nat => nat => bool) (1::nat) (i::nat))
-     ((op &::bool => bool => bool)
-       ((op <=::nat => nat => bool) i
-         ((dimindex::('A::type => bool) => nat) (UNIV::'A::type => bool)))
-       ((op &::bool => bool => bool)
-         ((op <=::nat => nat => bool) (1::nat) (j::nat))
-         ((op <=::nat => nat => bool) j
-           ((dimindex::('A::type => bool) => nat)
-             (UNIV::'A::type => bool)))))))
- ((Trueprop::bool => prop)
-   ((op =::bool => bool => bool)
-     ((op =::'A::type finite_image => 'A::type finite_image => bool)
-       ((finite_index::nat => 'A::type finite_image) i)
-       ((finite_index::nat => 'A::type finite_image) j))
-     ((op =::nat => nat => bool) i j)))"
-  by (import hollight FINITE_INDEX_INJ)
-
-lemma FORALL_FINITE_INDEX: "(op =::bool => bool => bool)
- ((All::('N::type finite_image => bool) => bool)
-   (P::'N::type finite_image => bool))
- ((All::(nat => bool) => bool)
-   (%i::nat.
-       (op -->::bool => bool => bool)
-        ((op &::bool => bool => bool)
-          ((op <=::nat => nat => bool) (1::nat) i)
-          ((op <=::nat => nat => bool) i
-            ((dimindex::('N::type => bool) => nat)
-              (UNIV::'N::type => bool))))
-        (P ((finite_index::nat => 'N::type finite_image) i))))"
-  by (import hollight FORALL_FINITE_INDEX)
-
-typedef (open) ('A, 'B) cart = "{f. True}"  morphisms "dest_cart" "mk_cart"
-  apply (rule light_ex_imp_nonempty[where t="SOME f. True"])
-  by (import hollight TYDEF_cart)
-
-syntax
-  dest_cart :: _ 
-
-syntax
-  mk_cart :: _ 
-
-lemmas "TYDEF_cart_@intern" = typedef_hol2hollight 
-  [where a="a :: ('A, 'B) cart" and r=r ,
-   OF type_definition_cart]
-
-consts
-  "$" :: "('q_73536, 'q_73546) cart => nat => 'q_73536" ("$")
-
-defs
-  "$_def": "$ == %(u::('q_73536, 'q_73546) cart) ua::nat. dest_cart u (finite_index ua)"
-
-lemma "DEF_$": "$ = (%(u::('q_73536, 'q_73546) cart) ua::nat. dest_cart u (finite_index ua))"
-  by (import hollight "DEF_$")
-
-lemma CART_EQ: "(op =::bool => bool => bool)
- ((op =::('A::type, 'B::type) cart => ('A::type, 'B::type) cart => bool)
-   (x::('A::type, 'B::type) cart) (y::('A::type, 'B::type) cart))
- ((All::(nat => bool) => bool)
-   (%xa::nat.
-       (op -->::bool => bool => bool)
-        ((op &::bool => bool => bool)
-          ((op <=::nat => nat => bool) (1::nat) xa)
-          ((op <=::nat => nat => bool) xa
-            ((dimindex::('B::type => bool) => nat)
-              (UNIV::'B::type => bool))))
-        ((op =::'A::type => 'A::type => bool)
-          (($::('A::type, 'B::type) cart => nat => 'A::type) x xa)
-          (($::('A::type, 'B::type) cart => nat => 'A::type) y xa))))"
-  by (import hollight CART_EQ)
-
-definition
-  lambda :: "(nat => 'A) => ('A, 'B) cart"  where
-  "(op ==::((nat => 'A::type) => ('A::type, 'B::type) cart)
-        => ((nat => 'A::type) => ('A::type, 'B::type) cart) => prop)
- (lambda::(nat => 'A::type) => ('A::type, 'B::type) cart)
- (%u::nat => 'A::type.
-     (Eps::(('A::type, 'B::type) cart => bool) => ('A::type, 'B::type) cart)
-      (%f::('A::type, 'B::type) cart.
-          (All::(nat => bool) => bool)
-           (%i::nat.
-               (op -->::bool => bool => bool)
-                ((op &::bool => bool => bool)
-                  ((op <=::nat => nat => bool) (1::nat) i)
-                  ((op <=::nat => nat => bool) i
-                    ((dimindex::('B::type => bool) => nat)
-                      (UNIV::'B::type => bool))))
-                ((op =::'A::type => 'A::type => bool)
-                  (($::('A::type, 'B::type) cart => nat => 'A::type) f i)
-                  (u i)))))"
-
-lemma DEF_lambda: "(op =::((nat => 'A::type) => ('A::type, 'B::type) cart)
-       => ((nat => 'A::type) => ('A::type, 'B::type) cart) => bool)
- (lambda::(nat => 'A::type) => ('A::type, 'B::type) cart)
- (%u::nat => 'A::type.
-     (Eps::(('A::type, 'B::type) cart => bool) => ('A::type, 'B::type) cart)
-      (%f::('A::type, 'B::type) cart.
-          (All::(nat => bool) => bool)
-           (%i::nat.
-               (op -->::bool => bool => bool)
-                ((op &::bool => bool => bool)
-                  ((op <=::nat => nat => bool) (1::nat) i)
-                  ((op <=::nat => nat => bool) i
-                    ((dimindex::('B::type => bool) => nat)
-                      (UNIV::'B::type => bool))))
-                ((op =::'A::type => 'A::type => bool)
-                  (($::('A::type, 'B::type) cart => nat => 'A::type) f i)
-                  (u i)))))"
-  by (import hollight DEF_lambda)
-
-lemma LAMBDA_BETA: "(op ==>::prop => prop => prop)
- ((Trueprop::bool => prop)
-   ((op &::bool => bool => bool)
-     ((op <=::nat => nat => bool) (1::nat) (x::nat))
-     ((op <=::nat => nat => bool) x
-       ((dimindex::('B::type => bool) => nat) (UNIV::'B::type => bool)))))
- ((Trueprop::bool => prop)
-   ((op =::'A::type => 'A::type => bool)
-     (($::('A::type, 'B::type) cart => nat => 'A::type)
-       ((lambda::(nat => 'A::type) => ('A::type, 'B::type) cart)
-         (g::nat => 'A::type))
-       x)
-     (g x)))"
-  by (import hollight LAMBDA_BETA)
-
-lemma LAMBDA_UNIQUE: "(op =::bool => bool => bool)
- ((All::(nat => bool) => bool)
-   (%i::nat.
-       (op -->::bool => bool => bool)
-        ((op &::bool => bool => bool)
-          ((op <=::nat => nat => bool) (1::nat) i)
-          ((op <=::nat => nat => bool) i
-            ((dimindex::('B::type => bool) => nat)
-              (UNIV::'B::type => bool))))
-        ((op =::'A::type => 'A::type => bool)
-          (($::('A::type, 'B::type) cart => nat => 'A::type)
-            (x::('A::type, 'B::type) cart) i)
-          ((xa::nat => 'A::type) i))))
- ((op =::('A::type, 'B::type) cart => ('A::type, 'B::type) cart => bool)
-   ((lambda::(nat => 'A::type) => ('A::type, 'B::type) cart) xa) x)"
-  by (import hollight LAMBDA_UNIQUE)
-
-lemma LAMBDA_ETA: "lambda ($ (x::('q_73734, 'q_73738) cart)) = x"
-  by (import hollight LAMBDA_ETA)
-
-lemma FINITE_INDEX_INRANGE: "(Ex::(nat => bool) => bool)
- (%xa::nat.
-     (op &::bool => bool => bool) ((op <=::nat => nat => bool) (1::nat) xa)
-      ((op &::bool => bool => bool)
-        ((op <=::nat => nat => bool) xa
-          ((dimindex::('N::type => bool) => nat) (UNIV::'N::type => bool)))
-        ((All::(('A::type, 'N::type) cart => bool) => bool)
-          (%xb::('A::type, 'N::type) cart.
-              (op =::'A::type => 'A::type => bool)
-               (($::('A::type, 'N::type) cart => nat => 'A::type) xb
-                 (x::nat))
-               (($::('A::type, 'N::type) cart => nat => 'A::type) xb xa)))))"
-  by (import hollight FINITE_INDEX_INRANGE)
-
-lemma CART_EQ_FULL: "((x::('A, 'N) cart) = (y::('A, 'N) cart)) = (ALL i::nat. $ x i = $ y i)"
-  by (import hollight CART_EQ_FULL)
-
-typedef (open) ('A, 'B) finite_sum = "{x::nat.
- x : dotdot (NUMERAL (NUMERAL_BIT1 (0::nat)))
-      (dimindex UNIV + dimindex UNIV)}"  morphisms "dest_finite_sum" "mk_finite_sum"
-  apply (rule light_ex_imp_nonempty[where t="SOME x::nat.
-   x : dotdot (NUMERAL (NUMERAL_BIT1 (0::nat)))
-        (dimindex UNIV + dimindex UNIV)"])
-  by (import hollight TYDEF_finite_sum)
-
-syntax
-  dest_finite_sum :: _ 
-
-syntax
-  mk_finite_sum :: _ 
-
-lemmas "TYDEF_finite_sum_@intern" = typedef_hol2hollight 
-  [where a="a :: ('A, 'B) finite_sum" and r=r ,
-   OF type_definition_finite_sum]
-
-definition
-  pastecart :: "('A, 'M) cart => ('A, 'N) cart => ('A, ('M, 'N) finite_sum) cart"  where
-  "(op ==::(('A::type, 'M::type) cart
-         => ('A::type, 'N::type) cart
-            => ('A::type, ('M::type, 'N::type) finite_sum) cart)
-        => (('A::type, 'M::type) cart
-            => ('A::type, 'N::type) cart
-               => ('A::type, ('M::type, 'N::type) finite_sum) cart)
-           => prop)
- (pastecart::('A::type, 'M::type) cart
-             => ('A::type, 'N::type) cart
-                => ('A::type, ('M::type, 'N::type) finite_sum) cart)
- (%(u::('A::type, 'M::type) cart) ua::('A::type, 'N::type) cart.
-     (lambda::(nat => 'A::type)
-              => ('A::type, ('M::type, 'N::type) finite_sum) cart)
-      (%i::nat.
-          (If::bool => 'A::type => 'A::type => 'A::type)
-           ((op <=::nat => nat => bool) i
-             ((dimindex::('M::type => bool) => nat)
-               (UNIV::'M::type => bool)))
-           (($::('A::type, 'M::type) cart => nat => 'A::type) u i)
-           (($::('A::type, 'N::type) cart => nat => 'A::type) ua
-             ((op -::nat => nat => nat) i
-               ((dimindex::('M::type => bool) => nat)
-                 (UNIV::'M::type => bool))))))"
-
-lemma DEF_pastecart: "(op =::(('A::type, 'M::type) cart
-        => ('A::type, 'N::type) cart
-           => ('A::type, ('M::type, 'N::type) finite_sum) cart)
-       => (('A::type, 'M::type) cart
-           => ('A::type, 'N::type) cart
-              => ('A::type, ('M::type, 'N::type) finite_sum) cart)
-          => bool)
- (pastecart::('A::type, 'M::type) cart
-             => ('A::type, 'N::type) cart
-                => ('A::type, ('M::type, 'N::type) finite_sum) cart)
- (%(u::('A::type, 'M::type) cart) ua::('A::type, 'N::type) cart.
-     (lambda::(nat => 'A::type)
-              => ('A::type, ('M::type, 'N::type) finite_sum) cart)
-      (%i::nat.
-          (If::bool => 'A::type => 'A::type => 'A::type)
-           ((op <=::nat => nat => bool) i
-             ((dimindex::('M::type => bool) => nat)
-               (UNIV::'M::type => bool)))
-           (($::('A::type, 'M::type) cart => nat => 'A::type) u i)
-           (($::('A::type, 'N::type) cart => nat => 'A::type) ua
-             ((op -::nat => nat => nat) i
-               ((dimindex::('M::type => bool) => nat)
-                 (UNIV::'M::type => bool))))))"
-  by (import hollight DEF_pastecart)
-
-definition
-  fstcart :: "('A, ('M, 'N) finite_sum) cart => ('A, 'M) cart"  where
-  "fstcart == %u::('A, ('M, 'N) finite_sum) cart. lambda ($ u)"
-
-lemma DEF_fstcart: "fstcart = (%u::('A, ('M, 'N) finite_sum) cart. lambda ($ u))"
-  by (import hollight DEF_fstcart)
-
-definition
-  sndcart :: "('A, ('M, 'N) finite_sum) cart => ('A, 'N) cart"  where
-  "(op ==::(('A::type, ('M::type, 'N::type) finite_sum) cart
-         => ('A::type, 'N::type) cart)
-        => (('A::type, ('M::type, 'N::type) finite_sum) cart
-            => ('A::type, 'N::type) cart)
-           => prop)
- (sndcart::('A::type, ('M::type, 'N::type) finite_sum) cart
-           => ('A::type, 'N::type) cart)
- (%u::('A::type, ('M::type, 'N::type) finite_sum) cart.
-     (lambda::(nat => 'A::type) => ('A::type, 'N::type) cart)
-      (%i::nat.
-          ($::('A::type, ('M::type, 'N::type) finite_sum) cart
-              => nat => 'A::type)
-           u ((op +::nat => nat => nat) i
-               ((dimindex::('M::type => bool) => nat)
-                 (UNIV::'M::type => bool)))))"
-
-lemma DEF_sndcart: "(op =::(('A::type, ('M::type, 'N::type) finite_sum) cart
-        => ('A::type, 'N::type) cart)
-       => (('A::type, ('M::type, 'N::type) finite_sum) cart
-           => ('A::type, 'N::type) cart)
-          => bool)
- (sndcart::('A::type, ('M::type, 'N::type) finite_sum) cart
-           => ('A::type, 'N::type) cart)
- (%u::('A::type, ('M::type, 'N::type) finite_sum) cart.
-     (lambda::(nat => 'A::type) => ('A::type, 'N::type) cart)
-      (%i::nat.
-          ($::('A::type, ('M::type, 'N::type) finite_sum) cart
-              => nat => 'A::type)
-           u ((op +::nat => nat => nat) i
-               ((dimindex::('M::type => bool) => nat)
-                 (UNIV::'M::type => bool)))))"
-  by (import hollight DEF_sndcart)
-
-lemma FINITE_SUM_IMAGE: "(op =::(('A::type, 'B::type) finite_sum => bool)
-       => (('A::type, 'B::type) finite_sum => bool) => bool)
- (UNIV::('A::type, 'B::type) finite_sum => bool)
- ((op `::(nat => ('A::type, 'B::type) finite_sum)
-         => (nat => bool) => ('A::type, 'B::type) finite_sum => bool)
-   (mk_finite_sum::nat => ('A::type, 'B::type) finite_sum)
-   ((atLeastAtMost::nat => nat => nat => bool) (1::nat)
-     ((op +::nat => nat => nat)
-       ((dimindex::('A::type => bool) => nat) (UNIV::'A::type => bool))
-       ((dimindex::('B::type => bool) => nat) (UNIV::'B::type => bool)))))"
-  by (import hollight FINITE_SUM_IMAGE)
-
-lemma HAS_SIZE_1: "(HAS_SIZE::(unit => bool) => nat => bool) (UNIV::unit => bool) (1::nat)"
-  by (import hollight HAS_SIZE_1)
-
-typedef (open) N_2 = "{x. x : dotdot (NUMERAL (NUMERAL_BIT1 0))
-         (NUMERAL (NUMERAL_BIT0 (NUMERAL_BIT1 0)))}"  morphisms "dest_auto_define_finite_type_2" "mk_auto_define_finite_type_2"
-  apply (rule light_ex_imp_nonempty[where t="SOME x.
-   x : dotdot (NUMERAL (NUMERAL_BIT1 0))
-        (NUMERAL (NUMERAL_BIT0 (NUMERAL_BIT1 0)))"])
-  by (import hollight TYDEF_2)
-
-syntax
-  dest_auto_define_finite_type_2 :: _ 
-
-syntax
-  mk_auto_define_finite_type_2 :: _ 
-
-lemmas "TYDEF_2_@intern" = typedef_hol2hollight 
-  [where a="a :: N_2" and r=r ,
-   OF type_definition_N_2]
-
-typedef (open) N_3 = "{x. x : dotdot (NUMERAL (NUMERAL_BIT1 0))
-         (NUMERAL (NUMERAL_BIT1 (NUMERAL_BIT1 0)))}"  morphisms "dest_auto_define_finite_type_3" "mk_auto_define_finite_type_3"
-  apply (rule light_ex_imp_nonempty[where t="SOME x.
-   x : dotdot (NUMERAL (NUMERAL_BIT1 0))
-        (NUMERAL (NUMERAL_BIT1 (NUMERAL_BIT1 0)))"])
-  by (import hollight TYDEF_3)
-
-syntax
-  dest_auto_define_finite_type_3 :: _ 
-
-syntax
-  mk_auto_define_finite_type_3 :: _ 
-
-lemmas "TYDEF_3_@intern" = typedef_hol2hollight 
-  [where a="a :: N_3" and r=r ,
-   OF type_definition_N_3]
-
-lemma FINITE_CART: "(op ==>::prop => prop => prop)
- ((all::(nat => prop) => prop)
-   (%i::nat.
-       (op ==>::prop => prop => prop)
-        ((Trueprop::bool => prop)
-          ((op &::bool => bool => bool)
-            ((op <=::nat => nat => bool) (1::nat) i)
-            ((op <=::nat => nat => bool) i
-              ((dimindex::('N::type => bool) => nat)
-                (UNIV::'N::type => bool)))))
-        ((Trueprop::bool => prop)
-          ((finite::('A::type => bool) => bool)
-            ((Collect::('A::type => bool) => 'A::type => bool)
-              (%u::'A::type.
-                  (Ex::('A::type => bool) => bool)
-                   (%x::'A::type.
-                       (op &::bool => bool => bool)
-                        ((P::nat => 'A::type => bool) i x)
-                        ((op =::'A::type => 'A::type => bool) u x))))))))
- ((Trueprop::bool => prop)
-   ((finite::(('A::type, 'N::type) cart => bool) => bool)
-     ((Collect::(('A::type, 'N::type) cart => bool)
-                => ('A::type, 'N::type) cart => bool)
-       (%u::('A::type, 'N::type) cart.
-           (Ex::(('A::type, 'N::type) cart => bool) => bool)
-            (%v::('A::type, 'N::type) cart.
-                (op &::bool => bool => bool)
-                 ((All::(nat => bool) => bool)
-                   (%i::nat.
-                       (op -->::bool => bool => bool)
-                        ((op &::bool => bool => bool)
-                          ((op <=::nat => nat => bool) (1::nat) i)
-                          ((op <=::nat => nat => bool) i
-                            ((dimindex::('N::type => bool) => nat)
-                              (UNIV::'N::type => bool))))
-                        (P i (($::('A::type, 'N::type) cart
-                                  => nat => 'A::type)
-                               v i))))
-                 ((op =::('A::type, 'N::type) cart
-                         => ('A::type, 'N::type) cart => bool)
-                   u v))))))"
-  by (import hollight FINITE_CART)
-
-definition
-  vector :: "'A list => ('A, 'N) cart"  where
-  "(op ==::('A::type list => ('A::type, 'N::type) cart)
-        => ('A::type list => ('A::type, 'N::type) cart) => prop)
- (vector::'A::type list => ('A::type, 'N::type) cart)
- (%u::'A::type list.
-     (lambda::(nat => 'A::type) => ('A::type, 'N::type) cart)
-      (%i::nat.
-          (op !::'A::type list => nat => 'A::type) u
-           ((op -::nat => nat => nat) i (1::nat))))"
-
-lemma DEF_vector: "(op =::('A::type list => ('A::type, 'N::type) cart)
-       => ('A::type list => ('A::type, 'N::type) cart) => bool)
- (vector::'A::type list => ('A::type, 'N::type) cart)
- (%u::'A::type list.
-     (lambda::(nat => 'A::type) => ('A::type, 'N::type) cart)
-      (%i::nat.
-          (op !::'A::type list => nat => 'A::type) u
-           ((op -::nat => nat => nat) i (1::nat))))"
-  by (import hollight DEF_vector)
-
-definition
-  CASEWISE :: "(('q_74835 => 'q_74839) * ('q_74840 => 'q_74835 => 'q_74799)) list
-=> 'q_74840 => 'q_74839 => 'q_74799"  where
-  "CASEWISE ==
-SOME CASEWISE::(('q_74835 => 'q_74839) *
-                ('q_74840 => 'q_74835 => 'q_74799)) list
-               => 'q_74840 => 'q_74839 => 'q_74799.
-   (ALL (f::'q_74840) x::'q_74839.
-       CASEWISE [] f x = (SOME y::'q_74799. True)) &
-   (ALL (h::('q_74835 => 'q_74839) * ('q_74840 => 'q_74835 => 'q_74799))
-       (t::(('q_74835 => 'q_74839) *
-            ('q_74840 => 'q_74835 => 'q_74799)) list)
-       (f::'q_74840) x::'q_74839.
-       CASEWISE (h # t) f x =
-       (if EX y::'q_74835. fst h y = x
-        then snd h f (SOME y::'q_74835. fst h y = x) else CASEWISE t f x))"
-
-lemma DEF_CASEWISE: "CASEWISE =
-(SOME CASEWISE::(('q_74835 => 'q_74839) *
-                 ('q_74840 => 'q_74835 => 'q_74799)) list
-                => 'q_74840 => 'q_74839 => 'q_74799.
-    (ALL (f::'q_74840) x::'q_74839.
-        CASEWISE [] f x = (SOME y::'q_74799. True)) &
-    (ALL (h::('q_74835 => 'q_74839) * ('q_74840 => 'q_74835 => 'q_74799))
-        (t::(('q_74835 => 'q_74839) *
-             ('q_74840 => 'q_74835 => 'q_74799)) list)
-        (f::'q_74840) x::'q_74839.
-        CASEWISE (h # t) f x =
-        (if EX y::'q_74835. fst h y = x
-         then snd h f (SOME y::'q_74835. fst h y = x) else CASEWISE t f x)))"
-  by (import hollight DEF_CASEWISE)
-
-definition
-  admissible :: "('q_75137 => 'q_75130 => bool)
-=> (('q_75137 => 'q_75133) => 'q_75143 => bool)
-   => ('q_75143 => 'q_75130)
-      => (('q_75137 => 'q_75133) => 'q_75143 => 'q_75138) => bool"  where
-  "admissible ==
-%(u::'q_75137 => 'q_75130 => bool)
-   (ua::('q_75137 => 'q_75133) => 'q_75143 => bool)
-   (ub::'q_75143 => 'q_75130)
-   uc::('q_75137 => 'q_75133) => 'q_75143 => 'q_75138.
-   ALL (f::'q_75137 => 'q_75133) (g::'q_75137 => 'q_75133) a::'q_75143.
-      ua f a & ua g a & (ALL z::'q_75137. u z (ub a) --> f z = g z) -->
-      uc f a = uc g a"
-
-lemma DEF_admissible: "admissible =
-(%(u::'q_75137 => 'q_75130 => bool)
-    (ua::('q_75137 => 'q_75133) => 'q_75143 => bool)
-    (ub::'q_75143 => 'q_75130)
-    uc::('q_75137 => 'q_75133) => 'q_75143 => 'q_75138.
-    ALL (f::'q_75137 => 'q_75133) (g::'q_75137 => 'q_75133) a::'q_75143.
-       ua f a & ua g a & (ALL z::'q_75137. u z (ub a) --> f z = g z) -->
-       uc f a = uc g a)"
-  by (import hollight DEF_admissible)
-
-definition
-  tailadmissible :: "('A => 'A => bool)
-=> (('A => 'B) => 'P => bool)
-   => ('P => 'A) => (('A => 'B) => 'P => 'B) => bool"  where
-  "tailadmissible ==
-%(u::'A => 'A => bool) (ua::('A => 'B) => 'P => bool) (ub::'P => 'A)
-   uc::('A => 'B) => 'P => 'B.
-   EX (P::('A => 'B) => 'P => bool) (G::('A => 'B) => 'P => 'A)
-      H::('A => 'B) => 'P => 'B.
-      (ALL (f::'A => 'B) (a::'P) y::'A.
-          P f a & u y (G f a) --> u y (ub a)) &
-      (ALL (f::'A => 'B) (g::'A => 'B) a::'P.
-          (ALL z::'A. u z (ub a) --> f z = g z) -->
-          P f a = P g a & G f a = G g a & H f a = H g a) &
-      (ALL (f::'A => 'B) a::'P.
-          ua f a --> uc f a = (if P f a then f (G f a) else H f a))"
-
-lemma DEF_tailadmissible: "tailadmissible =
-(%(u::'A => 'A => bool) (ua::('A => 'B) => 'P => bool) (ub::'P => 'A)
-    uc::('A => 'B) => 'P => 'B.
-    EX (P::('A => 'B) => 'P => bool) (G::('A => 'B) => 'P => 'A)
-       H::('A => 'B) => 'P => 'B.
-       (ALL (f::'A => 'B) (a::'P) y::'A.
-           P f a & u y (G f a) --> u y (ub a)) &
-       (ALL (f::'A => 'B) (g::'A => 'B) a::'P.
-           (ALL z::'A. u z (ub a) --> f z = g z) -->
-           P f a = P g a & G f a = G g a & H f a = H g a) &
-       (ALL (f::'A => 'B) a::'P.
-           ua f a --> uc f a = (if P f a then f (G f a) else H f a)))"
-  by (import hollight DEF_tailadmissible)
-
-definition
-  superadmissible :: "('q_75287 => 'q_75287 => bool)
-=> (('q_75287 => 'q_75289) => 'q_75295 => bool)
-   => ('q_75295 => 'q_75287)
-      => (('q_75287 => 'q_75289) => 'q_75295 => 'q_75289) => bool"  where
-  "superadmissible ==
-%(u::'q_75287 => 'q_75287 => bool)
-   (ua::('q_75287 => 'q_75289) => 'q_75295 => bool)
-   (ub::'q_75295 => 'q_75287)
-   uc::('q_75287 => 'q_75289) => 'q_75295 => 'q_75289.
-   admissible u (%(f::'q_75287 => 'q_75289) a::'q_75295. True) ub ua -->
-   tailadmissible u ua ub uc"
-
-lemma DEF_superadmissible: "superadmissible =
-(%(u::'q_75287 => 'q_75287 => bool)
-    (ua::('q_75287 => 'q_75289) => 'q_75295 => bool)
-    (ub::'q_75295 => 'q_75287)
-    uc::('q_75287 => 'q_75289) => 'q_75295 => 'q_75289.
-    admissible u (%(f::'q_75287 => 'q_75289) a::'q_75295. True) ub ua -->
-    tailadmissible u ua ub uc)"
-  by (import hollight DEF_superadmissible)
-
-lemma MATCH_SEQPATTERN: "_MATCH (x::'q_75330)
- (_SEQPATTERN (r::'q_75330 => 'q_75323 => bool)
-   (s::'q_75330 => 'q_75323 => bool)) =
-(if Ex (r x) then _MATCH x r else _MATCH x s)"
-  by (import hollight MATCH_SEQPATTERN)
-
-lemma ADMISSIBLE_CONST: "admissible (u_556::'q_75351 => 'q_75350 => bool)
- (x::('q_75351 => 'q_75352) => 'q_75353 => bool) (xa::'q_75353 => 'q_75350)
- (%f::'q_75351 => 'q_75352. xb::'q_75353 => 'q_75354)"
-  by (import hollight ADMISSIBLE_CONST)
-
-lemma ADMISSIBLE_BASE: "(!!(f::'A => 'B) a::'P.
-    (xa::('A => 'B) => 'P => bool) f a
-    ==> (x::'A => 'A => bool) ((xc::'P => 'A) a) ((xb::'P => 'A) a))
-==> admissible x xa xb (%(f::'A => 'B) x::'P. f (xc x))"
-  by (import hollight ADMISSIBLE_BASE)
-
-lemma ADMISSIBLE_COMB: "admissible (x::'A => 'A => bool) (xa::('A => 'B) => 'P => bool)
- (xb::'P => 'A) (xc::('A => 'B) => 'P => 'C => 'D) &
-admissible x xa xb (xd::('A => 'B) => 'P => 'C)
-==> admissible x xa xb (%(f::'A => 'B) x::'P. xc f x (xd f x))"
-  by (import hollight ADMISSIBLE_COMB)
-
-lemma ADMISSIBLE_RAND: "admissible (x::'A => 'A => bool) (xa::('A => 'B) => 'P => bool)
- (xb::'P => 'A) (xd::('A => 'B) => 'P => 'C)
-==> admissible x xa xb
-     (%(f::'A => 'B) x::'P. (xc::'P => 'C => 'D) x (xd f x))"
-  by (import hollight ADMISSIBLE_RAND)
-
-lemma ADMISSIBLE_LAMBDA: "admissible (x::'A => 'A => bool)
- (%f::'A => 'B.
-     SOME fa::'C * 'P => bool.
-        ALL (u::'C) x::'P. fa (u, x) = (xa::('A => 'B) => 'P => bool) f x)
- (SOME f::'C * 'P => 'A. ALL (u::'C) x::'P. f (u, x) = (xb::'P => 'A) x)
- (%f::'A => 'B.
-     SOME fa::'C * 'P => bool.
-        ALL (u::'C) x::'P.
-           fa (u, x) = (xc::('A => 'B) => 'C => 'P => bool) f u x)
-==> admissible x xa xb (%(f::'A => 'B) (x::'P) u::'C. xc f u x)"
-  by (import hollight ADMISSIBLE_LAMBDA)
-
-lemma ADMISSIBLE_NEST: "admissible (x::'A => 'A => bool) (xa::('A => 'B) => 'P => bool)
- (xb::'P => 'A) (xc::('A => 'B) => 'P => 'A) &
-(ALL (f::'A => 'B) a::'P. xa f a --> x (xc f a) (xb a))
-==> admissible x xa xb (%(f::'A => 'B) x::'P. f (xc f x))"
-  by (import hollight ADMISSIBLE_NEST)
-
-lemma ADMISSIBLE_COND: "admissible (u_556::'q_75688 => 'q_75687 => bool)
- (p::('q_75688 => 'q_75719) => 'P => bool) (s::'P => 'q_75687)
- (P::('q_75688 => 'q_75719) => 'P => bool) &
-admissible u_556 (%(f::'q_75688 => 'q_75719) x::'P. p f x & P f x) s
- (h::('q_75688 => 'q_75719) => 'P => 'q_75744) &
-admissible u_556 (%(f::'q_75688 => 'q_75719) x::'P. p f x & ~ P f x) s
- (k::('q_75688 => 'q_75719) => 'P => 'q_75744)
-==> admissible u_556 p s
-     (%(f::'q_75688 => 'q_75719) x::'P. if P f x then h f x else k f x)"
-  by (import hollight ADMISSIBLE_COND)
-
-lemma ADMISSIBLE_MATCH: "admissible (x::'q_75790 => 'q_75789 => bool)
- (xa::('q_75790 => 'q_75791) => 'P => bool) (xb::'P => 'q_75789)
- (xc::('q_75790 => 'q_75791) => 'P => 'q_75826) &
-admissible x xa xb
- (%(f::'q_75790 => 'q_75791) x::'P.
-     (c::('q_75790 => 'q_75791) => 'P => 'q_75826 => 'q_75823 => bool) f x
-      (xc f x))
-==> admissible x xa xb
-     (%(f::'q_75790 => 'q_75791) x::'P. _MATCH (xc f x) (c f x))"
-  by (import hollight ADMISSIBLE_MATCH)
-
-lemma ADMISSIBLE_SEQPATTERN: "admissible (x::'q_75867 => 'q_75866 => bool)
- (xa::('q_75867 => 'q_75929) => 'P => bool) (xb::'P => 'q_75866)
- (%(f::'q_75867 => 'q_75929) x::'P.
-     Ex ((xc::('q_75867 => 'q_75929) => 'P => 'q_75955 => 'q_75945 => bool)
-          f x ((xe::('q_75867 => 'q_75929) => 'P => 'q_75955) f x))) &
-admissible x
- (%(f::'q_75867 => 'q_75929) x::'P. xa f x & Ex (xc f x (xe f x))) xb
- (%(f::'q_75867 => 'q_75929) x::'P. xc f x (xe f x)) &
-admissible x
- (%(f::'q_75867 => 'q_75929) x::'P. xa f x & ~ Ex (xc f x (xe f x))) xb
- (%(f::'q_75867 => 'q_75929) x::'P.
-     (xd::('q_75867 => 'q_75929) => 'P => 'q_75955 => 'q_75945 => bool) f x
-      (xe f x))
-==> admissible x xa xb
-     (%(f::'q_75867 => 'q_75929) x::'P.
-         _SEQPATTERN (xc f x) (xd f x) (xe f x))"
-  by (import hollight ADMISSIBLE_SEQPATTERN)
-
-lemma ADMISSIBLE_UNGUARDED_PATTERN: "admissible (u_556::'q_76041 => 'q_76040 => bool)
- (p::('q_76041 => 'q_76088) => 'P => bool) (s::'P => 'q_76040)
- (pat::('q_76041 => 'q_76088) => 'P => 'q_76121) &
-admissible u_556 p s (e::('q_76041 => 'q_76088) => 'P => 'q_76121) &
-admissible u_556 (%(f::'q_76041 => 'q_76088) x::'P. p f x & pat f x = e f x)
- s (t::('q_76041 => 'q_76088) => 'P => 'q_76128) &
-admissible u_556 (%(f::'q_76041 => 'q_76088) x::'P. p f x & pat f x = e f x)
- s (y::('q_76041 => 'q_76088) => 'P => 'q_76128)
-==> admissible u_556 p s
-     (%(f::'q_76041 => 'q_76088) x::'P.
-         _UNGUARDED_PATTERN (pat f x = e f x) (t f x = y f x))"
-  by (import hollight ADMISSIBLE_UNGUARDED_PATTERN)
-
-lemma ADMISSIBLE_GUARDED_PATTERN: "admissible (u_556::'q_76215 => 'q_76214 => bool)
- (p::('q_76215 => 'q_76292) => 'P => bool) (s::'P => 'q_76214)
- (pat::('q_76215 => 'q_76292) => 'P => 'q_76330) &
-admissible u_556 p s (e::('q_76215 => 'q_76292) => 'P => 'q_76330) &
-admissible u_556
- (%(f::'q_76215 => 'q_76292) x::'P.
-     p f x &
-     pat f x = e f x & (q::('q_76215 => 'q_76292) => 'P => bool) f x)
- s (t::('q_76215 => 'q_76292) => 'P => 'q_76339) &
-admissible u_556 (%(f::'q_76215 => 'q_76292) x::'P. p f x & pat f x = e f x)
- s q &
-admissible u_556
- (%(f::'q_76215 => 'q_76292) x::'P. p f x & pat f x = e f x & q f x) s
- (y::('q_76215 => 'q_76292) => 'P => 'q_76339)
-==> admissible u_556 p s
-     (%(f::'q_76215 => 'q_76292) x::'P.
-         _GUARDED_PATTERN (pat f x = e f x) (q f x) (t f x = y f x))"
-  by (import hollight ADMISSIBLE_GUARDED_PATTERN)
-
-lemma ADMISSIBLE_NSUM: "admissible (x::'B => 'A => bool)
- (%f::'B => 'C.
-     SOME fa::nat * 'P => bool.
-        ALL (k::nat) x::'P.
-           fa (k, x) =
-           ((xd::'P => nat) x <= k &
-            k <= (xe::'P => nat) x & (xa::('B => 'C) => 'P => bool) f x))
- (SOME f::nat * 'P => 'A. ALL (k::nat) x::'P. f (k, x) = (xb::'P => 'A) x)
- (%f::'B => 'C.
-     SOME fa::nat * 'P => nat.
-        ALL (k::nat) x::'P.
-           fa (k, x) = (xc::('B => 'C) => 'P => nat => nat) f x k)
-==> admissible x xa xb (%(f::'B => 'C) x::'P. nsum {xd x..xe x} (xc f x))"
-  by (import hollight ADMISSIBLE_NSUM)
-
-lemma ADMISSIBLE_SUM: "admissible (x::'B => 'A => bool)
- (%f::'B => 'C.
-     SOME fa::nat * 'P => bool.
-        ALL (k::nat) x::'P.
-           fa (k, x) =
-           ((xd::'P => nat) x <= k &
-            k <= (xe::'P => nat) x & (xa::('B => 'C) => 'P => bool) f x))
- (SOME f::nat * 'P => 'A. ALL (k::nat) x::'P. f (k, x) = (xb::'P => 'A) x)
- (%f::'B => 'C.
-     SOME fa::nat * 'P => hollight.real.
-        ALL (k::nat) x::'P.
-           fa (k, x) = (xc::('B => 'C) => 'P => nat => hollight.real) f x k)
-==> admissible x xa xb
-     (%(f::'B => 'C) x::'P. hollight.sum {xd x..xe x} (xc f x))"
-  by (import hollight ADMISSIBLE_SUM)
-
-lemma ADMISSIBLE_MAP: "admissible (x::'A => 'q_76632 => bool) (xa::('A => 'B) => 'P => bool)
- (xb::'P => 'q_76632) (xd::('A => 'B) => 'P => 'q_76647 list) &
-admissible x
- (%f::'A => 'B.
-     SOME fa::'q_76647 * 'P => bool.
-        ALL (y::'q_76647) x::'P. fa (y, x) = (xa f x & y : set (xd f x)))
- (SOME f::'q_76647 * 'P => 'q_76632.
-     ALL (y::'q_76647) x::'P. f (y, x) = xb x)
- (%f::'A => 'B.
-     SOME fa::'q_76647 * 'P => 'q_76641.
-        ALL (y::'q_76647) x::'P.
-           fa (y, x) = (xc::('A => 'B) => 'P => 'q_76647 => 'q_76641) f x y)
-==> admissible x xa xb (%(f::'A => 'B) x::'P. map (xc f x) (xd f x))"
-  by (import hollight ADMISSIBLE_MAP)
-
-lemma ADMISSIBLE_MATCH_SEQPATTERN: "admissible (x::'q_76705 => 'q_76704 => bool)
- (xa::('q_76705 => 'q_76770) => 'P => bool) (xb::'P => 'q_76704)
- (%(f::'q_76705 => 'q_76770) x::'P.
-     Ex ((xc::('q_76705 => 'q_76770) => 'P => 'q_76825 => 'q_76794 => bool)
-          f x ((xe::('q_76705 => 'q_76770) => 'P => 'q_76825) f x))) &
-admissible x
- (%(f::'q_76705 => 'q_76770) x::'P. xa f x & Ex (xc f x (xe f x))) xb
- (%(f::'q_76705 => 'q_76770) x::'P. _MATCH (xe f x) (xc f x)) &
-admissible x
- (%(f::'q_76705 => 'q_76770) x::'P. xa f x & ~ Ex (xc f x (xe f x))) xb
- (%(f::'q_76705 => 'q_76770) x::'P.
-     _MATCH (xe f x)
-      ((xd::('q_76705 => 'q_76770) => 'P => 'q_76825 => 'q_76794 => bool) f
-        x))
-==> admissible x xa xb
-     (%(x::'q_76705 => 'q_76770) xa::'P.
-         _MATCH (xe x xa) (_SEQPATTERN (xc x xa) (xd x xa)))"
-  by (import hollight ADMISSIBLE_MATCH_SEQPATTERN)
-
-lemma ADMISSIBLE_IMP_SUPERADMISSIBLE: "admissible (x::'A => 'A => bool) (xa::('A => 'B) => 'P => bool)
- (xb::'P => 'A) (xc::('A => 'B) => 'P => 'B)
-==> superadmissible x xa xb xc"
-  by (import hollight ADMISSIBLE_IMP_SUPERADMISSIBLE)
-
-lemma SUPERADMISSIBLE_CONST: "superadmissible (u_556::'q_76904 => 'q_76904 => bool)
- (p::('q_76904 => 'q_76906) => 'q_76905 => bool) (s::'q_76905 => 'q_76904)
- (%f::'q_76904 => 'q_76906. c::'q_76905 => 'q_76906)"
-  by (import hollight SUPERADMISSIBLE_CONST)
-
-lemma SUPERADMISSIBLE_TAIL: "admissible (x::'A => 'A => bool) (xa::('A => 'B) => 'P => bool)
- (xb::'P => 'A) (xc::('A => 'B) => 'P => 'A) &
-(ALL (f::'A => 'B) a::'P.
-    xa f a --> (ALL y::'A. x y (xc f a) --> x y (xb a)))
-==> superadmissible x xa xb (%(f::'A => 'B) x::'P. f (xc f x))"
-  by (import hollight SUPERADMISSIBLE_TAIL)
-
-lemma SUPERADMISSIBLE_COND: "admissible (x::'A => 'A => bool) (xa::('A => 'B) => 'P => bool)
- (xc::'P => 'A) (xb::('A => 'B) => 'P => bool) &
-superadmissible x (%(f::'A => 'B) x::'P. xa f x & xb f x) xc
- (xd::('A => 'B) => 'P => 'B) &
-superadmissible x (%(f::'A => 'B) x::'P. xa f x & ~ xb f x) xc
- (xe::('A => 'B) => 'P => 'B)
-==> superadmissible x xa xc
-     (%(f::'A => 'B) x::'P. if xb f x then xd f x else xe f x)"
-  by (import hollight SUPERADMISSIBLE_COND)
-
-lemma SUPERADMISSIBLE_MATCH_SEQPATTERN: "admissible (x::'q_77225 => 'q_77225 => bool)
- (xa::('q_77225 => 'q_77341) => 'P => bool) (xb::'P => 'q_77225)
- (%(f::'q_77225 => 'q_77341) x::'P.
-     Ex ((xc::('q_77225 => 'q_77341) => 'P => 'q_77340 => 'q_77341 => bool)
-          f x ((xe::('q_77225 => 'q_77341) => 'P => 'q_77340) f x))) &
-superadmissible x
- (%(f::'q_77225 => 'q_77341) x::'P. xa f x & Ex (xc f x (xe f x))) xb
- (%(f::'q_77225 => 'q_77341) x::'P. _MATCH (xe f x) (xc f x)) &
-superadmissible x
- (%(f::'q_77225 => 'q_77341) x::'P. xa f x & ~ Ex (xc f x (xe f x))) xb
- (%(f::'q_77225 => 'q_77341) x::'P.
-     _MATCH (xe f x)
-      ((xd::('q_77225 => 'q_77341) => 'P => 'q_77340 => 'q_77341 => bool) f
-        x))
-==> superadmissible x xa xb
-     (%(x::'q_77225 => 'q_77341) xa::'P.
-         _MATCH (xe x xa) (_SEQPATTERN (xc x xa) (xd x xa)))"
-  by (import hollight SUPERADMISSIBLE_MATCH_SEQPATTERN)
-
-lemma SUPERADMISSIBLE_MATCH_UNGUARDED_PATTERN: "(ALL (f::'A => 'B) (a::'P) (t::'Q) u::'Q.
-    (p::('A => 'B) => 'P => bool) f a &
-    (pat::'Q => 'D) t = (e::'P => 'D) a & pat u = e a -->
-    (arg::'P => 'Q => 'A) a t = arg a u) &
-(ALL (f::'A => 'B) (a::'P) t::'Q.
-    p f a & pat t = e a -->
-    (ALL y::'A.
-        (u_556::'A => 'A => bool) y (arg a t) -->
-        u_556 y ((s::'P => 'A) a)))
-==> superadmissible u_556 p s
-     (%(f::'A => 'B) x::'P.
-         _MATCH (e x)
-          (%(u::'D) v::'B.
-              EX t::'Q. _UNGUARDED_PATTERN (pat t = u) (f (arg x t) = v)))"
-  by (import hollight SUPERADMISSIBLE_MATCH_UNGUARDED_PATTERN)
-
-lemma SUPERADMISSIBLE_MATCH_GUARDED_PATTERN: "(ALL (f::'A => 'B) (a::'P) (t::'Q) u::'Q.
-    (p::('A => 'B) => 'P => bool) f a &
-    (pat::'Q => 'D) t = (e::'P => 'D) a &
-    (q::'P => 'Q => bool) a t & pat u = e a & q a u -->
-    (arg::'P => 'Q => 'A) a t = arg a u) &
-(ALL (f::'A => 'B) (a::'P) t::'Q.
-    p f a & q a t & pat t = e a -->
-    (ALL y::'A.
-        (u_556::'A => 'A => bool) y (arg a t) -->
-        u_556 y ((s::'P => 'A) a)))
-==> superadmissible u_556 p s
-     (%(f::'A => 'B) x::'P.
-         _MATCH (e x)
-          (%(u::'D) v::'B.
-              EX t::'Q.
-                 _GUARDED_PATTERN (pat t = u) (q x t) (f (arg x t) = v)))"
-  by (import hollight SUPERADMISSIBLE_MATCH_GUARDED_PATTERN)
-
-lemma cth: "[| !!(c::'q_78547) (x::'A) y::'A.
-      (p1::'A => 'q_78536) x = (p1'::'A => 'q_78536) y
-      ==> (p2::'q_78547 => 'A => 'q_78541) c x =
-          (p2'::'q_78547 => 'A => 'q_78541) c y;
-   p1' (x::'A) = p1 (y::'A) |]
-==> p2' (c::'q_78547) x = p2 c y"
-  by (import hollight cth)
-
-lemma SUPERADMISSIBLE_T: "superadmissible (u_556::'q_78694 => 'q_78694 => bool)
- (%(f::'q_78694 => 'q_78696) x::'q_78700. True) (s::'q_78700 => 'q_78694)
- (t::('q_78694 => 'q_78696) => 'q_78700 => 'q_78696) =
-tailadmissible u_556 (%(f::'q_78694 => 'q_78696) x::'q_78700. True) s t"
-  by (import hollight SUPERADMISSIBLE_T)
-
-lemma elemma0: "(ALL z::'q_78985 * 'q_78984.
-    (f::'q_78985 * 'q_78984 => 'q_78975) z =
-    (g::'q_78985 * 'q_78984 => 'q_78975) z) =
-(ALL (x::'q_78985) y::'q_78984. f (x, y) = g (x, y)) &
-(P::'q_79002 * 'q_79001 => 'q_78994) =
-(SOME f::'q_79002 * 'q_79001 => 'q_78994.
-    ALL (x::'q_79002) y::'q_79001. f (x, y) = P (x, y))"
-  by (import hollight elemma0)
-
-;end_setup
-
-end
-
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOLLight/ROOT.ML
--- a/src/HOL/Import/HOLLight/ROOT.ML	Sat Mar 03 21:51:38 2012 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1 +0,0 @@
-use_thy "HOLLight";
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOLLight/hollight.imp
--- a/src/HOL/Import/HOLLight/hollight.imp	Sat Mar 03 21:51:38 2012 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,2335 +0,0 @@
-import
-
-import_segment "hollight"
-
-def_maps
-  "vector" > "vector_def"
-  "treal_of_num" > "treal_of_num_def"
-  "treal_neg" > "treal_neg_def"
-  "treal_mul" > "treal_mul_def"
-  "treal_le" > "treal_le_def"
-  "treal_inv" > "treal_inv_def"
-  "treal_eq" > "treal_eq_def"
-  "treal_add" > "treal_add_def"
-  "tailadmissible" > "tailadmissible_def"
-  "support" > "support_def"
-  "superadmissible" > "superadmissible_def"
-  "sum" > "sum_def"
-  "sndcart" > "sndcart_def"
-  "rem" > "rem_def"
-  "real_sub" > "real_sub_def"
-  "real_sgn" > "real_sgn_def"
-  "real_pow" > "real_pow_def"
-  "real_of_num" > "real_of_num_def"
-  "real_neg" > "real_neg_def"
-  "real_mul" > "real_mul_def"
-  "real_mod" > "real_mod_def"
-  "real_min" > "real_min_def"
-  "real_max" > "real_max_def"
-  "real_lt" > "real_lt_def"
-  "real_le" > "real_le_def"
-  "real_inv" > "real_inv_def"
-  "real_gt" > "real_gt_def"
-  "real_ge" > "real_ge_def"
-  "real_div" > "real_div_def"
-  "real_add" > "real_add_def"
-  "real_abs" > "real_abs_def"
-  "pastecart" > "pastecart_def"
-  "pairwise" > "pairwise_def"
-  "num_of_int" > "num_of_int_def"
-  "num_mod" > "num_mod_def"
-  "num_gcd" > "num_gcd_def"
-  "num_divides" > "num_divides_def"
-  "num_coprime" > "num_coprime_def"
-  "nsum" > "nsum_def"
-  "neutral" > "neutral_def"
-  "nadd_rinv" > "nadd_rinv_def"
-  "nadd_of_num" > "nadd_of_num_def"
-  "nadd_mul" > "nadd_mul_def"
-  "nadd_le" > "nadd_le_def"
-  "nadd_inv" > "nadd_inv_def"
-  "nadd_eq" > "nadd_eq_def"
-  "nadd_add" > "nadd_add_def"
-  "monoidal" > "monoidal_def"
-  "minimal" > "minimal_def"
-  "lambda" > "lambda_def"
-  "iterate" > "iterate_def"
-  "is_nadd" > "is_nadd_def"
-  "integer" > "integer_def"
-  "int_sub" > "int_sub_def"
-  "int_sgn" > "int_sgn_def"
-  "int_pow" > "int_pow_def"
-  "int_of_num" > "int_of_num_def"
-  "int_neg" > "int_neg_def"
-  "int_mul" > "int_mul_def"
-  "int_mod" > "int_mod_def"
-  "int_min" > "int_min_def"
-  "int_max" > "int_max_def"
-  "int_lt" > "int_lt_def"
-  "int_le" > "int_le_def"
-  "int_gt" > "int_gt_def"
-  "int_ge" > "int_ge_def"
-  "int_gcd" > "int_gcd_def"
-  "int_divides" > "int_divides_def"
-  "int_coprime" > "int_coprime_def"
-  "int_add" > "int_add_def"
-  "int_abs" > "int_abs_def"
-  "hreal_of_num" > "hreal_of_num_def"
-  "hreal_mul" > "hreal_mul_def"
-  "hreal_le" > "hreal_le_def"
-  "hreal_inv" > "hreal_inv_def"
-  "hreal_add" > "hreal_add_def"
-  "fstcart" > "fstcart_def"
-  "eqeq" > "eqeq_def"
-  "div" > "div_def"
-  "dist" > "dist_def"
-  "dimindex" > "dimindex_def"
-  "admissible" > "admissible_def"
-  "_UNGUARDED_PATTERN" > "_UNGUARDED_PATTERN_def"
-  "_SEQPATTERN" > "_SEQPATTERN_def"
-  "_MATCH" > "_MATCH_def"
-  "_GUARDED_PATTERN" > "_GUARDED_PATTERN_def"
-  "_FUNCTION" > "_FUNCTION_def"
-  "_FALSITY_" > "_FALSITY__def"
-  "_11937" > "_11937_def"
-  "ZRECSPACE" > "ZRECSPACE_def"
-  "ZCONSTR" > "ZCONSTR_def"
-  "ZBOT" > "ZBOT_def"
-  "UNCURRY" > "UNCURRY_def"
-  "SURJ" > "SURJ_def"
-  "SING" > "SING_def"
-  "REST" > "REST_def"
-  "PASSOC" > "PASSOC_def"
-  "PAIRWISE" > "PAIRWISE_def"
-  "NUM_REP" > "NUM_REP_def"
-  "NUMSUM" > "NUMSUM_def"
-  "NUMSND" > "NUMSND_def"
-  "NUMRIGHT" > "NUMRIGHT_def"
-  "NUMPAIR" > "NUMPAIR_def"
-  "NUMLEFT" > "NUMLEFT_def"
-  "NUMFST" > "NUMFST_def"
-  "LET_END" > "LET_END_def"
-  "ITSET" > "ITSET_def"
-  "ISO" > "ISO_def"
-  "INJP" > "INJP_def"
-  "INJN" > "INJN_def"
-  "INJF" > "INJF_def"
-  "INJA" > "INJA_def"
-  "INJ" > "INJ_def"
-  "IND_SUC" > "IND_SUC_def"
-  "IND_0" > "IND_0_def"
-  "HAS_SIZE" > "HAS_SIZE_def"
-  "FNIL" > "FNIL_def"
-  "FINREC" > "FINREC_def"
-  "FCONS" > "FCONS_def"
-  "DECIMAL" > "DECIMAL_def"
-  "CROSS" > "CROSS_def"
-  "COUNTABLE" > "COUNTABLE_def"
-  "CONSTR" > "CONSTR_def"
-  "CASEWISE" > "CASEWISE_def"
-  "CARD" > "CARD_def"
-  "BOTTOM" > "BOTTOM_def"
-  "BIJ" > "BIJ_def"
-  "ASCII" > "ASCII_def"
-  ">_c" > ">_c_def"
-  ">=_c" > ">=_c_def"
-  "=_c" > "=_c_def"
-  "<_c" > "<_c_def"
-  "<=_c" > "<=_c_def"
-  "$" > "$_def"
-
-type_maps
-  "sum" > "Sum_Type.sum"
-  "recspace" > "HOLLight.hollight.recspace"
-  "real" > "HOLLight.hollight.real"
-  "prod" > "Product_Type.prod"
-  "option" > "Datatype.option"
-  "num" > "Nat.nat"
-  "nadd" > "HOLLight.hollight.nadd"
-  "list" > "List.list"
-  "int" > "HOLLight.hollight.int"
-  "ind" > "Nat.ind"
-  "hreal" > "HOLLight.hollight.hreal"
-  "fun" > "fun"
-  "finite_sum" > "HOLLight.hollight.finite_sum"
-  "finite_image" > "HOLLight.hollight.finite_image"
-  "char" > "HOLLight.hollight.char"
-  "cart" > "HOLLight.hollight.cart"
-  "bool" > "HOL.bool"
-  "N_3" > "HOLLight.hollight.N_3"
-  "N_2" > "HOLLight.hollight.N_2"
-  "N_1" > "Product_Type.unit"
-
-const_maps
-  "~" > "HOL.Not"
-  "vector" > "HOLLight.hollight.vector"
-  "treal_of_num" > "HOLLight.hollight.treal_of_num"
-  "treal_neg" > "HOLLight.hollight.treal_neg"
-  "treal_mul" > "HOLLight.hollight.treal_mul"
-  "treal_le" > "HOLLight.hollight.treal_le"
-  "treal_inv" > "HOLLight.hollight.treal_inv"
-  "treal_eq" > "HOLLight.hollight.treal_eq"
-  "treal_add" > "HOLLight.hollight.treal_add"
-  "tailadmissible" > "HOLLight.hollight.tailadmissible"
-  "support" > "HOLLight.hollight.support"
-  "superadmissible" > "HOLLight.hollight.superadmissible"
-  "sum" > "HOLLight.hollight.sum"
-  "sndcart" > "HOLLight.hollight.sndcart"
-  "set_of_list" > "List.set"
-  "rem" > "HOLLight.hollight.rem"
-  "real_sub" > "HOLLight.hollight.real_sub"
-  "real_sgn" > "HOLLight.hollight.real_sgn"
-  "real_pow" > "HOLLight.hollight.real_pow"
-  "real_of_num" > "HOLLight.hollight.real_of_num"
-  "real_neg" > "HOLLight.hollight.real_neg"
-  "real_mul" > "HOLLight.hollight.real_mul"
-  "real_mod" > "HOLLight.hollight.real_mod"
-  "real_min" > "HOLLight.hollight.real_min"
-  "real_max" > "HOLLight.hollight.real_max"
-  "real_lt" > "HOLLight.hollight.real_lt"
-  "real_le" > "HOLLight.hollight.real_le"
-  "real_inv" > "HOLLight.hollight.real_inv"
-  "real_gt" > "HOLLight.hollight.real_gt"
-  "real_ge" > "HOLLight.hollight.real_ge"
-  "real_div" > "HOLLight.hollight.real_div"
-  "real_add" > "HOLLight.hollight.real_add"
-  "real_abs" > "HOLLight.hollight.real_abs"
-  "pastecart" > "HOLLight.hollight.pastecart"
-  "pairwise" > "HOLLight.hollight.pairwise"
-  "one" > "Product_Type.Unity"
-  "o" > "Fun.comp"
-  "num_of_int" > "HOLLight.hollight.num_of_int"
-  "num_mod" > "HOLLight.hollight.num_mod"
-  "num_gcd" > "HOLLight.hollight.num_gcd"
-  "num_divides" > "HOLLight.hollight.num_divides"
-  "num_coprime" > "HOLLight.hollight.num_coprime"
-  "nsum" > "HOLLight.hollight.nsum"
-  "neutral" > "HOLLight.hollight.neutral"
-  "nadd_rinv" > "HOLLight.hollight.nadd_rinv"
-  "nadd_of_num" > "HOLLight.hollight.nadd_of_num"
-  "nadd_mul" > "HOLLight.hollight.nadd_mul"
-  "nadd_le" > "HOLLight.hollight.nadd_le"
-  "nadd_inv" > "HOLLight.hollight.nadd_inv"
-  "nadd_eq" > "HOLLight.hollight.nadd_eq"
-  "nadd_add" > "HOLLight.hollight.nadd_add"
-  "monoidal" > "HOLLight.hollight.monoidal"
-  "mk_pair" > "Product_Type.Pair_Rep"
-  "mk_num" > "Fun.id"
-  "minimal" > "HOLLight.hollight.minimal"
-  "list_EX" > "List.list_ex"
-  "list_ALL" > "List.list_all"
-  "lambda" > "HOLLight.hollight.lambda"
-  "iterate" > "HOLLight.hollight.iterate"
-  "is_nadd" > "HOLLight.hollight.is_nadd"
-  "integer" > "HOLLight.hollight.integer"
-  "int_sub" > "HOLLight.hollight.int_sub"
-  "int_sgn" > "HOLLight.hollight.int_sgn"
-  "int_pow" > "HOLLight.hollight.int_pow"
-  "int_of_num" > "HOLLight.hollight.int_of_num"
-  "int_neg" > "HOLLight.hollight.int_neg"
-  "int_mul" > "HOLLight.hollight.int_mul"
-  "int_mod" > "HOLLight.hollight.int_mod"
-  "int_min" > "HOLLight.hollight.int_min"
-  "int_max" > "HOLLight.hollight.int_max"
-  "int_lt" > "HOLLight.hollight.int_lt"
-  "int_le" > "HOLLight.hollight.int_le"
-  "int_gt" > "HOLLight.hollight.int_gt"
-  "int_ge" > "HOLLight.hollight.int_ge"
-  "int_gcd" > "HOLLight.hollight.int_gcd"
-  "int_divides" > "HOLLight.hollight.int_divides"
-  "int_coprime" > "HOLLight.hollight.int_coprime"
-  "int_add" > "HOLLight.hollight.int_add"
-  "int_abs" > "HOLLight.hollight.int_abs"
-  "hreal_of_num" > "HOLLight.hollight.hreal_of_num"
-  "hreal_mul" > "HOLLight.hollight.hreal_mul"
-  "hreal_le" > "HOLLight.hollight.hreal_le"
-  "hreal_inv" > "HOLLight.hollight.hreal_inv"
-  "hreal_add" > "HOLLight.hollight.hreal_add"
-  "fstcart" > "HOLLight.hollight.fstcart"
-  "eqeq" > "HOLLight.hollight.eqeq"
-  "div" > "HOLLight.hollight.div"
-  "dist" > "HOLLight.hollight.dist"
-  "dimindex" > "HOLLight.hollight.dimindex"
-  "admissible" > "HOLLight.hollight.admissible"
-  "_UNGUARDED_PATTERN" > "HOLLight.hollight._UNGUARDED_PATTERN"
-  "_SEQPATTERN" > "HOLLight.hollight._SEQPATTERN"
-  "_MATCH" > "HOLLight.hollight._MATCH"
-  "_GUARDED_PATTERN" > "HOLLight.hollight._GUARDED_PATTERN"
-  "_FUNCTION" > "HOLLight.hollight._FUNCTION"
-  "_FALSITY_" > "HOLLight.hollight._FALSITY_"
-  "_11937" > "HOLLight.hollight._11937"
-  "_0" > "Groups.zero_class.zero" :: "nat"
-  "\\/" > "HOL.disj"
-  "ZRECSPACE" > "HOLLight.hollight.ZRECSPACE"
-  "ZIP" > "List.zip"
-  "ZCONSTR" > "HOLLight.hollight.ZCONSTR"
-  "ZBOT" > "HOLLight.hollight.ZBOT"
-  "WF" > "Wellfounded.wfP"
-  "UNIV" > "Orderings.top_class.top" :: "'a => bool"
-  "UNIONS" > "Complete_Lattices.Sup_class.Sup" :: "(('a => bool) => bool) => 'a => bool"
-  "UNION" > "Lattices.sup_class.sup" :: "('a => bool) => ('a => bool) => 'a => bool"
-  "UNCURRY" > "HOLLight.hollight.UNCURRY"
-  "TL" > "List.tl"
-  "T" > "HOL.True"
-  "SURJ" > "HOLLight.hollight.SURJ"
-  "SUC" > "Nat.Suc"
-  "SUBSET" > "Orderings.ord_class.less_eq" :: "('a => bool) => ('a => bool) => bool"
-  "SOME" > "Datatype.Some"
-  "SND" > "Product_Type.snd"
-  "SING" > "HOLLight.hollight.SING"
-  "SETSPEC" > "HOLLightCompat.SETSPEC"
-  "REVERSE" > "List.rev"
-  "REST" > "HOLLight.hollight.REST"
-  "REPLICATE" > "List.replicate"
-  "PSUBSET" > "Orderings.ord_class.less" :: "('a => bool) => ('a => bool) => bool"
-  "PRE" > "HOLLightCompat.Pred"
-  "PASSOC" > "HOLLight.hollight.PASSOC"
-  "PAIRWISE" > "HOLLight.hollight.PAIRWISE"
-  "OUTR" > "HOLLightCompat.OUTR"
-  "OUTL" > "HOLLightCompat.OUTL"
-  "ONTO" > "Fun.surj"
-  "ONE_ONE" > "Fun.inj"
-  "ODD" > "HOLLightCompat.ODD"
-  "NUM_REP" > "HOLLight.hollight.NUM_REP"
-  "NUMSUM" > "HOLLight.hollight.NUMSUM"
-  "NUMSND" > "HOLLight.hollight.NUMSND"
-  "NUMRIGHT" > "HOLLight.hollight.NUMRIGHT"
-  "NUMPAIR" > "HOLLight.hollight.NUMPAIR"
-  "NUMLEFT" > "HOLLight.hollight.NUMLEFT"
-  "NUMFST" > "HOLLight.hollight.NUMFST"
-  "NUMERAL" > "HOLLightCompat.NUMERAL"
-  "NULL" > "List.null"
-  "NONE" > "Datatype.None"
-  "NIL" > "List.list.Nil"
-  "MOD" > "Divides.div_class.mod" :: "nat => nat => nat"
-  "MIN" > "Orderings.ord_class.min" :: "nat => nat => nat"
-  "MEM" > "HOLLightList.list_mem"
-  "MEASURE" > "HOLLightCompat.MEASURE"
-  "MAX" > "Orderings.ord_class.max" :: "nat => nat => nat"
-  "MAP2" > "HOLLightList.map2"
-  "MAP" > "List.map"
-  "LET_END" > "HOLLight.hollight.LET_END"
-  "LET" > "HOLLightCompat.LET"
-  "LENGTH" > "List.length"
-  "LAST" > "List.last"
-  "ITSET" > "HOLLight.hollight.ITSET"
-  "ITLIST2" > "HOLLightList.fold2"
-  "ITLIST" > "List.foldr"
-  "ISO" > "HOLLight.hollight.ISO"
-  "INTERS" > "Complete_Lattices.Inf_class.Inf" :: "(('a => bool) => bool) => 'a => bool"
-  "INTER" > "Lattices.inf_class.inf" :: "('a => bool) => ('a => bool) => 'a => bool"
-  "INSERT" > "Set.insert"
-  "INR" > "Sum_Type.Inr"
-  "INL" > "Sum_Type.Inl"
-  "INJP" > "HOLLight.hollight.INJP"
-  "INJN" > "HOLLight.hollight.INJN"
-  "INJF" > "HOLLight.hollight.INJF"
-  "INJA" > "HOLLight.hollight.INJA"
-  "INJ" > "HOLLight.hollight.INJ"
-  "INFINITE" > "HOLLightCompat.INFINITE"
-  "IND_SUC" > "HOLLight.hollight.IND_SUC"
-  "IND_0" > "HOLLight.hollight.IND_0"
-  "IN" > "Set.member"
-  "IMAGE" > "Set.image"
-  "I" > "Fun.id"
-  "HD" > "List.hd"
-  "HAS_SIZE" > "HOLLight.hollight.HAS_SIZE"
-  "GSPEC" > "Set.Collect"
-  "GEQ" > "HOL.eq"
-  "GABS" > "Hilbert_Choice.Eps"
-  "FST" > "Product_Type.fst"
-  "FNIL" > "HOLLight.hollight.FNIL"
-  "FINREC" > "HOLLight.hollight.FINREC"
-  "FINITE" > "Finite_Set.finite"
-  "FILTER" > "List.filter"
-  "FCONS" > "HOLLight.hollight.FCONS"
-  "FACT" > "Fact.fact_class.fact" :: "nat => nat"
-  "F" > "HOL.False"
-  "EXP" > "Power.power_class.power" :: "nat => nat => nat"
-  "EVEN" > "Parity.even_odd_class.even" :: "nat => bool"
-  "EMPTY" > "Orderings.bot_class.bot" :: "'a => bool"
-  "EL" > "HOLLightList.list_el"
-  "DIV" > "Divides.div_class.div" :: "nat => nat => nat"
-  "DISJOINT" > "HOLLightCompat.DISJOINT"
-  "DIFF" > "Groups.minus_class.minus" :: "('a => bool) => ('a => bool) => 'a => bool"
-  "DELETE" > "HOLLightCompat.DELETE"
-  "DECIMAL" > "HOLLight.hollight.DECIMAL"
-  "CURRY" > "Product_Type.curry"
-  "CROSS" > "HOLLight.hollight.CROSS"
-  "COUNTABLE" > "HOLLight.hollight.COUNTABLE"
-  "CONSTR" > "HOLLight.hollight.CONSTR"
-  "CONS" > "List.list.Cons"
-  "COND" > "HOL.If"
-  "CHOICE" > "Hilbert_Choice.Eps"
-  "CASEWISE" > "HOLLight.hollight.CASEWISE"
-  "CARD" > "HOLLight.hollight.CARD"
-  "BUTLAST" > "List.butlast"
-  "BOTTOM" > "HOLLight.hollight.BOTTOM"
-  "BIT1" > "HOLLightCompat.NUMERAL_BIT1"
-  "BIT0" > "HOLLightCompat.NUMERAL_BIT0"
-  "BIJ" > "HOLLight.hollight.BIJ"
-  "ASCII" > "HOLLight.hollight.ASCII"
-  "APPEND" > "List.append"
-  "ALL2" > "List.list_all2"
-  "@" > "Hilbert_Choice.Eps"
-  "?!" > "HOL.Ex1"
-  "?" > "HOL.Ex"
-  ">_c" > "HOLLight.hollight.>_c"
-  ">=_c" > "HOLLight.hollight.>=_c"
-  ">=" > "Orderings.ord_class.greater_eq" :: "nat => nat => bool"
-  ">" > "Orderings.ord_class.greater" :: "nat => nat => bool"
-  "=_c" > "HOLLight.hollight.=_c"
-  "==>" > "HOL.implies"
-  "=" > "HOL.eq"
-  "<_c" > "HOLLight.hollight.<_c"
-  "<=_c" > "HOLLight.hollight.<=_c"
-  "<=" > "Orderings.ord_class.less_eq" :: "nat => nat => bool"
-  "<" > "Orderings.ord_class.less" :: "nat => nat => bool"
-  "/\\" > "HOL.conj"
-  ".." > "HOLLightCompat.dotdot"
-  "-" > "Groups.minus_class.minus" :: "nat => nat => nat"
-  "," > "Product_Type.Pair"
-  "+" > "Groups.plus_class.plus" :: "nat => nat => nat"
-  "*" > "Groups.times_class.times" :: "nat => nat => nat"
-  "$" > "HOLLight.hollight.$"
-  "!" > "HOL.All"
-
-const_renames
-  "EX" > "list_EX"
-  "ALL" > "list_ALL"
-  "==" > "eqeq"
-
-thm_maps
-  "vector_def" > "HOLLight.hollight.vector_def"
-  "treal_of_num_def" > "HOLLight.hollight.treal_of_num_def"
-  "treal_neg_def" > "HOLLight.hollight.treal_neg_def"
-  "treal_mul_def" > "HOLLight.hollight.treal_mul_def"
-  "treal_le_def" > "HOLLight.hollight.treal_le_def"
-  "treal_inv_def" > "HOLLight.hollight.treal_inv_def"
-  "treal_eq_def" > "HOLLight.hollight.treal_eq_def"
-  "treal_add_def" > "HOLLight.hollight.treal_add_def"
-  "th_cond" > "HOLLight.hollight.th_cond"
-  "th" > "HOL.eta_contract_eq"
-  "tailadmissible_def" > "HOLLight.hollight.tailadmissible_def"
-  "support_def" > "HOLLight.hollight.support_def"
-  "superadmissible_def" > "HOLLight.hollight.superadmissible_def"
-  "sum_def" > "HOLLight.hollight.sum_def"
-  "string_INFINITE" > "List.infinite_UNIV_listI"
-  "sth" > "HOLLight.hollight.sth"
-  "sndcart_def" > "HOLLight.hollight.sndcart_def"
-  "right_th" > "HOLLight.hollight.right_th"
-  "rem_def" > "HOLLight.hollight.rem_def"
-  "real_sub_def" > "HOLLight.hollight.real_sub_def"
-  "real_sgn_def" > "HOLLight.hollight.real_sgn_def"
-  "real_pow_def" > "HOLLight.hollight.real_pow_def"
-  "real_of_num_def" > "HOLLight.hollight.real_of_num_def"
-  "real_neg_def" > "HOLLight.hollight.real_neg_def"
-  "real_mul_def" > "HOLLight.hollight.real_mul_def"
-  "real_mod_def" > "HOLLight.hollight.real_mod_def"
-  "real_min_def" > "HOLLight.hollight.real_min_def"
-  "real_max_def" > "HOLLight.hollight.real_max_def"
-  "real_lt_def" > "HOLLight.hollight.real_lt_def"
-  "real_le_def" > "HOLLight.hollight.real_le_def"
-  "real_inv_def" > "HOLLight.hollight.real_inv_def"
-  "real_gt_def" > "HOLLight.hollight.real_gt_def"
-  "real_ge_def" > "HOLLight.hollight.real_ge_def"
-  "real_div_def" > "HOLLight.hollight.real_div_def"
-  "real_add_def" > "HOLLight.hollight.real_add_def"
-  "real_abs_def" > "HOLLight.hollight.real_abs_def"
-  "real_INFINITE" > "HOLLight.hollight.real_INFINITE"
-  "pastecart_def" > "HOLLight.hollight.pastecart_def"
-  "pairwise_def" > "HOLLight.hollight.pairwise_def"
-  "pair_RECURSION" > "HOLLight.hollight.pair_RECURSION"
-  "pair_INDUCT" > "Product_Type.prod.induct"
-  "one_axiom" > "HOLLight.hollight.one_axiom"
-  "one_RECURSION" > "HOLLight.hollight.one_RECURSION"
-  "one_INDUCT" > "Product_Type.unit.induct"
-  "one_Axiom" > "HOLLight.hollight.one_Axiom"
-  "one" > "HOLLightCompat.one"
-  "o_THM" > "Fun.comp_def"
-  "o_ASSOC" > "HOLLight.hollight.o_ASSOC"
-  "num_of_int_def" > "HOLLight.hollight.num_of_int_def"
-  "num_mod_def" > "HOLLight.hollight.num_mod_def"
-  "num_gcd_def" > "HOLLight.hollight.num_gcd_def"
-  "num_divides_def" > "HOLLight.hollight.num_divides_def"
-  "num_coprime_def" > "HOLLight.hollight.num_coprime_def"
-  "num_congruent" > "HOLLight.hollight.num_congruent"
-  "num_WOP" > "HOLLight.hollight.num_WOP"
-  "num_WF" > "Nat.nat_less_induct"
-  "num_RECURSION_STD" > "HOLLight.hollight.num_RECURSION_STD"
-  "num_MAX" > "HOLLight.hollight.num_MAX"
-  "num_INFINITE" > "Finite_Set.infinite_UNIV_char_0"
-  "num_INDUCTION" > "Fact.fact_nat.induct"
-  "num_FINITE_AVOID" > "HOLLight.hollight.num_FINITE_AVOID"
-  "num_FINITE" > "HOLLight.hollight.num_FINITE"
-  "num_CASES" > "Nat.nat.nchotomy"
-  "num_Axiom" > "HOLLightCompat.num_Axiom"
-  "nsum_def" > "HOLLight.hollight.nsum_def"
-  "neutral_def" > "HOLLight.hollight.neutral_def"
-  "nadd_rinv_def" > "HOLLight.hollight.nadd_rinv_def"
-  "nadd_of_num_def" > "HOLLight.hollight.nadd_of_num_def"
-  "nadd_mul_def" > "HOLLight.hollight.nadd_mul_def"
-  "nadd_le_def" > "HOLLight.hollight.nadd_le_def"
-  "nadd_inv_def" > "HOLLight.hollight.nadd_inv_def"
-  "nadd_eq_def" > "HOLLight.hollight.nadd_eq_def"
-  "nadd_add_def" > "HOLLight.hollight.nadd_add_def"
-  "monoidal_def" > "HOLLight.hollight.monoidal_def"
-  "minimal_def" > "HOLLight.hollight.minimal_def"
-  "list_INDUCT" > "List.list.induct"
-  "list_CASES" > "List.list.nchotomy"
-  "lambda_def" > "HOLLight.hollight.lambda_def"
-  "iterate_def" > "HOLLight.hollight.iterate_def"
-  "is_nadd_def" > "HOLLight.hollight.is_nadd_def"
-  "is_nadd_0" > "HOLLight.hollight.is_nadd_0"
-  "is_int" > "HOLLight.hollight.is_int"
-  "integer_def" > "HOLLight.hollight.integer_def"
-  "int_sub_th" > "HOLLight.hollight.int_sub_th"
-  "int_sub_def" > "HOLLight.hollight.int_sub_def"
-  "int_sgn_th" > "HOLLight.hollight.int_sgn_th"
-  "int_sgn_def" > "HOLLight.hollight.int_sgn_def"
-  "int_pow_th" > "HOLLight.hollight.int_pow_th"
-  "int_pow_def" > "HOLLight.hollight.int_pow_def"
-  "int_of_num_th" > "HOLLight.hollight.int_of_num_th"
-  "int_of_num_def" > "HOLLight.hollight.int_of_num_def"
-  "int_neg_th" > "HOLLight.hollight.int_neg_th"
-  "int_neg_def" > "HOLLight.hollight.int_neg_def"
-  "int_mul_th" > "HOLLight.hollight.int_mul_th"
-  "int_mul_def" > "HOLLight.hollight.int_mul_def"
-  "int_mod_def" > "HOLLight.hollight.int_mod_def"
-  "int_min_th" > "HOLLight.hollight.int_min_th"
-  "int_min_def" > "HOLLight.hollight.int_min_def"
-  "int_max_th" > "HOLLight.hollight.int_max_th"
-  "int_max_def" > "HOLLight.hollight.int_max_def"
-  "int_lt_def" > "HOLLight.hollight.int_lt_def"
-  "int_le_def" > "HOLLight.hollight.int_le_def"
-  "int_gt_def" > "HOLLight.hollight.int_gt_def"
-  "int_ge_def" > "HOLLight.hollight.int_ge_def"
-  "int_gcd_def" > "HOLLight.hollight.int_gcd_def"
-  "int_eq" > "HOLLight.hollight.int.real_of_int_inject"
-  "int_divides_def" > "HOLLight.hollight.int_divides_def"
-  "int_coprime_def" > "HOLLight.hollight.int_coprime_def"
-  "int_congruent" > "HOLLight.hollight.int_congruent"
-  "int_add_th" > "HOLLight.hollight.int_add_th"
-  "int_add_def" > "HOLLight.hollight.int_add_def"
-  "int_abs_th" > "HOLLight.hollight.int_abs_th"
-  "int_abs_def" > "HOLLight.hollight.int_abs_def"
-  "hreal_of_num_def" > "HOLLight.hollight.hreal_of_num_def"
-  "hreal_mul_def" > "HOLLight.hollight.hreal_mul_def"
-  "hreal_le_def" > "HOLLight.hollight.hreal_le_def"
-  "hreal_inv_def" > "HOLLight.hollight.hreal_inv_def"
-  "hreal_add_def" > "HOLLight.hollight.hreal_add_def"
-  "fstcart_def" > "HOLLight.hollight.fstcart_def"
-  "eqeq_def" > "HOLLight.hollight.eqeq_def"
-  "elemma0" > "HOLLight.hollight.elemma0"
-  "div_def" > "HOLLight.hollight.div_def"
-  "dist_def" > "HOLLight.hollight.dist_def"
-  "dimindex_def" > "HOLLight.hollight.dimindex_def"
-  "dest_int_rep" > "HOLLight.hollight.dest_int_rep"
-  "cth" > "HOLLight.hollight.cth"
-  "bool_RECURSION" > "HOLLight.hollight.bool_RECURSION"
-  "bool_INDUCT" > "Product_Type.bool.induct"
-  "ax__3" > "HOL4Setup.INFINITY_AX"
-  "ax__2" > "Hilbert_Choice.someI"
-  "ax__1" > "HOL.eta_contract_eq"
-  "admissible_def" > "HOLLight.hollight.admissible_def"
-  "_UNGUARDED_PATTERN_def" > "HOLLight.hollight._UNGUARDED_PATTERN_def"
-  "_SEQPATTERN_def" > "HOLLight.hollight._SEQPATTERN_def"
-  "_MATCH_def" > "HOLLight.hollight._MATCH_def"
-  "_GUARDED_PATTERN_def" > "HOLLight.hollight._GUARDED_PATTERN_def"
-  "_FUNCTION_def" > "HOLLight.hollight._FUNCTION_def"
-  "_FALSITY__def" > "HOLLight.hollight._FALSITY__def"
-  "_11937_def" > "HOLLight.hollight._11937_def"
-  "ZRECSPACE_def" > "HOLLight.hollight.ZRECSPACE_def"
-  "ZIP" > "HOLLightList.ZIP"
-  "ZCONSTR_def" > "HOLLight.hollight.ZCONSTR_def"
-  "ZCONSTR_ZBOT" > "HOLLight.hollight.ZCONSTR_ZBOT"
-  "ZBOT_def" > "HOLLight.hollight.ZBOT_def"
-  "WLOG_LT" > "HOLLight.hollight.WLOG_LT"
-  "WLOG_LE" > "HOLLight.hollight.WLOG_LE"
-  "WF_num" > "HOLLight.hollight.WF_num"
-  "WF_UREC_WF" > "HOLLight.hollight.WF_UREC_WF"
-  "WF_UREC" > "HOLLight.hollight.WF_UREC"
-  "WF_SUBSET" > "HOLLight.hollight.WF_SUBSET"
-  "WF_REFL" > "HOLLight.hollight.WF_REFL"
-  "WF_REC_num" > "HOLLight.hollight.WF_REC_num"
-  "WF_REC_WF" > "HOLLight.hollight.WF_REC_WF"
-  "WF_REC_TAIL_GENERAL" > "HOLLight.hollight.WF_REC_TAIL_GENERAL"
-  "WF_REC_TAIL" > "HOLLight.hollight.WF_REC_TAIL"
-  "WF_REC_INVARIANT" > "HOLLight.hollight.WF_REC_INVARIANT"
-  "WF_REC" > "HOLLight.hollight.WF_REC"
-  "WF_POINTWISE" > "HOLLight.hollight.WF_POINTWISE"
-  "WF_MEASURE_GEN" > "HOLLight.hollight.WF_MEASURE_GEN"
-  "WF_MEASURE" > "HOLLight.hollight.WF_MEASURE"
-  "WF_LEX_DEPENDENT" > "HOLLight.hollight.WF_LEX_DEPENDENT"
-  "WF_LEX" > "HOLLight.hollight.WF_LEX"
-  "WF_INT_MEASURE_2" > "HOLLight.hollight.WF_INT_MEASURE_2"
-  "WF_INT_MEASURE" > "HOLLight.hollight.WF_INT_MEASURE"
-  "WF_IND" > "HOLLight.hollight.WF_IND"
-  "WF_FINITE" > "HOLLight.hollight.WF_FINITE"
-  "WF_FALSE" > "Wellfounded.wfP_empty"
-  "WF_EREC" > "HOLLight.hollight.WF_EREC"
-  "WF_EQ" > "HOLLight.hollight.WF_EQ"
-  "WF_DCHAIN" > "HOLLight.hollight.WF_DCHAIN"
-  "UNWIND_THM2" > "HOL.simp_thms_39"
-  "UNWIND_THM1" > "HOL.simp_thms_40"
-  "UNIV_SUBSET" > "Orderings.top_class.top_unique"
-  "UNIV_NOT_EMPTY" > "Set.UNIV_not_empty"
-  "UNIQUE_SKOLEM_THM" > "HOL.choice_eq"
-  "UNIQUE_SKOLEM_ALT" > "HOLLight.hollight.UNIQUE_SKOLEM_ALT"
-  "UNION_UNIV" > "HOLLight.hollight.UNION_UNIV"
-  "UNION_SUBSET" > "Lattices.semilattice_sup_class.le_sup_iff"
-  "UNION_OVER_INTER" > "Lattices.distrib_lattice_class.distrib_3"
-  "UNION_IDEMPOT" > "Big_Operators.lattice_class.Sup_fin.idem"
-  "UNION_EMPTY" > "HOLLight.hollight.UNION_EMPTY"
-  "UNION_COMM" > "Lattices.lattice_class.inf_sup_aci_5"
-  "UNION_ASSOC" > "Lattices.lattice_class.inf_sup_aci_6"
-  "UNION_ACI" > "HOLLight.hollight.UNION_ACI"
-  "UNIONS_UNION" > "Complete_Lattices.Union_Un_distrib"
-  "UNIONS_SUBSET" > "HOLLight.hollight.UNIONS_SUBSET"
-  "UNIONS_INTERS" > "HOLLight.hollight.UNIONS_INTERS"
-  "UNIONS_INSERT" > "Complete_Lattices.Union_insert"
-  "UNIONS_IMAGE" > "HOLLight.hollight.UNIONS_IMAGE"
-  "UNIONS_GSPEC" > "HOLLight.hollight.UNIONS_GSPEC"
-  "UNIONS_2" > "Complete_Lattices.Un_eq_Union"
-  "UNIONS_1" > "Complete_Lattices.complete_lattice_class.Sup_singleton"
-  "UNIONS_0" > "Complete_Lattices.Union_empty"
-  "UNCURRY_def" > "HOLLight.hollight.UNCURRY_def"
-  "TYDEF_recspace" > "HOLLight.hollight.TYDEF_recspace"
-  "TYDEF_real" > "HOLLight.hollight.TYDEF_real"
-  "TYDEF_nadd" > "HOLLight.hollight.TYDEF_nadd"
-  "TYDEF_int" > "HOLLight.hollight.TYDEF_int"
-  "TYDEF_hreal" > "HOLLight.hollight.TYDEF_hreal"
-  "TYDEF_finite_sum" > "HOLLight.hollight.TYDEF_finite_sum"
-  "TYDEF_finite_image" > "HOLLight.hollight.TYDEF_finite_image"
-  "TYDEF_char" > "HOLLight.hollight.TYDEF_char"
-  "TYDEF_cart" > "HOLLight.hollight.TYDEF_cart"
-  "TYDEF_3" > "HOLLight.hollight.TYDEF_3"
-  "TYDEF_2" > "HOLLight.hollight.TYDEF_2"
-  "TWO" > "HOLLight.hollight.TWO"
-  "TRIV_OR_FORALL_THM" > "HOLLight.hollight.TRIV_OR_FORALL_THM"
-  "TRIV_FORALL_OR_THM" > "HOLLight.hollight.TRIV_FORALL_OR_THM"
-  "TRIV_FORALL_IMP_THM" > "HOLLight.hollight.TRIV_FORALL_IMP_THM"
-  "TRIV_EXISTS_IMP_THM" > "HOLLight.hollight.TRIV_EXISTS_IMP_THM"
-  "TRIV_EXISTS_AND_THM" > "HOLLight.hollight.TRIV_EXISTS_AND_THM"
-  "TRIV_AND_EXISTS_THM" > "HOLLight.hollight.TRIV_AND_EXISTS_THM"
-  "TREAL_OF_NUM_WELLDEF" > "HOLLight.hollight.TREAL_OF_NUM_WELLDEF"
-  "TREAL_OF_NUM_MUL" > "HOLLight.hollight.TREAL_OF_NUM_MUL"
-  "TREAL_OF_NUM_LE" > "HOLLight.hollight.TREAL_OF_NUM_LE"
-  "TREAL_OF_NUM_EQ" > "HOLLight.hollight.TREAL_OF_NUM_EQ"
-  "TREAL_OF_NUM_ADD" > "HOLLight.hollight.TREAL_OF_NUM_ADD"
-  "TREAL_NEG_WELLDEF" > "HOLLight.hollight.TREAL_NEG_WELLDEF"
-  "TREAL_MUL_WELLDEFR" > "HOLLight.hollight.TREAL_MUL_WELLDEFR"
-  "TREAL_MUL_WELLDEF" > "HOLLight.hollight.TREAL_MUL_WELLDEF"
-  "TREAL_MUL_SYM_EQ" > "HOLLight.hollight.TREAL_MUL_SYM_EQ"
-  "TREAL_MUL_SYM" > "HOLLight.hollight.TREAL_MUL_SYM"
-  "TREAL_MUL_LINV" > "HOLLight.hollight.TREAL_MUL_LINV"
-  "TREAL_MUL_LID" > "HOLLight.hollight.TREAL_MUL_LID"
-  "TREAL_MUL_ASSOC" > "HOLLight.hollight.TREAL_MUL_ASSOC"
-  "TREAL_LE_WELLDEF" > "HOLLight.hollight.TREAL_LE_WELLDEF"
-  "TREAL_LE_TRANS" > "HOLLight.hollight.TREAL_LE_TRANS"
-  "TREAL_LE_TOTAL" > "HOLLight.hollight.TREAL_LE_TOTAL"
-  "TREAL_LE_REFL" > "HOLLight.hollight.TREAL_LE_REFL"
-  "TREAL_LE_MUL" > "HOLLight.hollight.TREAL_LE_MUL"
-  "TREAL_LE_LADD_IMP" > "HOLLight.hollight.TREAL_LE_LADD_IMP"
-  "TREAL_LE_ANTISYM" > "HOLLight.hollight.TREAL_LE_ANTISYM"
-  "TREAL_INV_WELLDEF" > "HOLLight.hollight.TREAL_INV_WELLDEF"
-  "TREAL_INV_0" > "HOLLight.hollight.TREAL_INV_0"
-  "TREAL_EQ_TRANS" > "HOLLight.hollight.TREAL_EQ_TRANS"
-  "TREAL_EQ_SYM" > "HOLLight.hollight.TREAL_EQ_SYM"
-  "TREAL_EQ_REFL" > "HOLLight.hollight.TREAL_EQ_REFL"
-  "TREAL_EQ_IMP_LE" > "HOLLight.hollight.TREAL_EQ_IMP_LE"
-  "TREAL_EQ_AP" > "HOLLight.hollight.TREAL_EQ_AP"
-  "TREAL_ADD_WELLDEFR" > "HOLLight.hollight.TREAL_ADD_WELLDEFR"
-  "TREAL_ADD_WELLDEF" > "HOLLight.hollight.TREAL_ADD_WELLDEF"
-  "TREAL_ADD_SYM_EQ" > "HOLLight.hollight.TREAL_ADD_SYM_EQ"
-  "TREAL_ADD_SYM" > "HOLLight.hollight.TREAL_ADD_SYM"
-  "TREAL_ADD_LINV" > "HOLLight.hollight.TREAL_ADD_LINV"
-  "TREAL_ADD_LID" > "HOLLight.hollight.TREAL_ADD_LID"
-  "TREAL_ADD_LDISTRIB" > "HOLLight.hollight.TREAL_ADD_LDISTRIB"
-  "TREAL_ADD_ASSOC" > "HOLLight.hollight.TREAL_ADD_ASSOC"
-  "TRANSITIVE_STEPWISE_LT_EQ" > "HOLLight.hollight.TRANSITIVE_STEPWISE_LT_EQ"
-  "TRANSITIVE_STEPWISE_LT" > "HOLLight.hollight.TRANSITIVE_STEPWISE_LT"
-  "TRANSITIVE_STEPWISE_LE_EQ" > "HOLLight.hollight.TRANSITIVE_STEPWISE_LE_EQ"
-  "TRANSITIVE_STEPWISE_LE" > "HOLLight.hollight.TRANSITIVE_STEPWISE_LE"
-  "TOPOLOGICAL_SORT" > "HOLLight.hollight.TOPOLOGICAL_SORT"
-  "SWAP_FORALL_THM" > "HOL.all_comm"
-  "SWAP_EXISTS_THM" > "HOL.ex_comm"
-  "SURJ_def" > "HOLLight.hollight.SURJ_def"
-  "SURJECTIVE_RIGHT_INVERSE" > "HOLLight.hollight.SURJECTIVE_RIGHT_INVERSE"
-  "SURJECTIVE_ON_RIGHT_INVERSE" > "HOLLight.hollight.SURJECTIVE_ON_RIGHT_INVERSE"
-  "SURJECTIVE_ON_IMAGE" > "HOLLight.hollight.SURJECTIVE_ON_IMAGE"
-  "SURJECTIVE_MAP" > "HOLLightList.SURJECTIVE_MAP"
-  "SURJECTIVE_IMAGE_THM" > "HOLLight.hollight.SURJECTIVE_IMAGE_THM"
-  "SURJECTIVE_IMAGE_EQ" > "HOLLight.hollight.SURJECTIVE_IMAGE_EQ"
-  "SURJECTIVE_IMAGE" > "HOLLight.hollight.SURJECTIVE_IMAGE"
-  "SURJECTIVE_IFF_INJECTIVE_GEN" > "HOLLight.hollight.SURJECTIVE_IFF_INJECTIVE_GEN"
-  "SURJECTIVE_IFF_INJECTIVE" > "HOLLight.hollight.SURJECTIVE_IFF_INJECTIVE"
-  "SURJECTIVE_FORALL_THM" > "HOLLight.hollight.SURJECTIVE_FORALL_THM"
-  "SURJECTIVE_EXISTS_THM" > "HOLLight.hollight.SURJECTIVE_EXISTS_THM"
-  "SUPPORT_SUPPORT" > "HOLLight.hollight.SUPPORT_SUPPORT"
-  "SUPPORT_SUBSET" > "HOLLight.hollight.SUPPORT_SUBSET"
-  "SUPPORT_EMPTY" > "HOLLight.hollight.SUPPORT_EMPTY"
-  "SUPPORT_DELTA" > "HOLLight.hollight.SUPPORT_DELTA"
-  "SUPPORT_CLAUSES" > "HOLLight.hollight.SUPPORT_CLAUSES"
-  "SUPERADMISSIBLE_TAIL" > "HOLLight.hollight.SUPERADMISSIBLE_TAIL"
-  "SUPERADMISSIBLE_T" > "HOLLight.hollight.SUPERADMISSIBLE_T"
-  "SUPERADMISSIBLE_MATCH_UNGUARDED_PATTERN" > "HOLLight.hollight.SUPERADMISSIBLE_MATCH_UNGUARDED_PATTERN"
-  "SUPERADMISSIBLE_MATCH_SEQPATTERN" > "HOLLight.hollight.SUPERADMISSIBLE_MATCH_SEQPATTERN"
-  "SUPERADMISSIBLE_MATCH_GUARDED_PATTERN" > "HOLLight.hollight.SUPERADMISSIBLE_MATCH_GUARDED_PATTERN"
-  "SUPERADMISSIBLE_CONST" > "HOLLight.hollight.SUPERADMISSIBLE_CONST"
-  "SUPERADMISSIBLE_COND" > "HOLLight.hollight.SUPERADMISSIBLE_COND"
-  "SUM_ZERO_EXISTS" > "HOLLight.hollight.SUM_ZERO_EXISTS"
-  "SUM_UNION_RZERO" > "HOLLight.hollight.SUM_UNION_RZERO"
-  "SUM_UNION_NONZERO" > "HOLLight.hollight.SUM_UNION_NONZERO"
-  "SUM_UNION_LZERO" > "HOLLight.hollight.SUM_UNION_LZERO"
-  "SUM_UNION_EQ" > "HOLLight.hollight.SUM_UNION_EQ"
-  "SUM_UNIONS_NONZERO" > "HOLLight.hollight.SUM_UNIONS_NONZERO"
-  "SUM_UNION" > "HOLLight.hollight.SUM_UNION"
-  "SUM_TRIV_NUMSEG" > "HOLLight.hollight.SUM_TRIV_NUMSEG"
-  "SUM_SWAP_NUMSEG" > "HOLLight.hollight.SUM_SWAP_NUMSEG"
-  "SUM_SWAP" > "HOLLight.hollight.SUM_SWAP"
-  "SUM_SUPPORT" > "HOLLight.hollight.SUM_SUPPORT"
-  "SUM_SUPERSET" > "HOLLight.hollight.SUM_SUPERSET"
-  "SUM_SUM_RESTRICT" > "HOLLight.hollight.SUM_SUM_RESTRICT"
-  "SUM_SUM_PRODUCT" > "HOLLight.hollight.SUM_SUM_PRODUCT"
-  "SUM_SUB_NUMSEG" > "HOLLight.hollight.SUM_SUB_NUMSEG"
-  "SUM_SUBSET_SIMPLE" > "HOLLight.hollight.SUM_SUBSET_SIMPLE"
-  "SUM_SUBSET" > "HOLLight.hollight.SUM_SUBSET"
-  "SUM_SUB" > "HOLLight.hollight.SUM_SUB"
-  "SUM_SING_NUMSEG" > "HOLLight.hollight.SUM_SING_NUMSEG"
-  "SUM_SING" > "HOLLight.hollight.SUM_SING"
-  "SUM_RMUL" > "HOLLight.hollight.SUM_RMUL"
-  "SUM_RESTRICT_SET" > "HOLLight.hollight.SUM_RESTRICT_SET"
-  "SUM_RESTRICT" > "HOLLight.hollight.SUM_RESTRICT"
-  "SUM_POS_LE_NUMSEG" > "HOLLight.hollight.SUM_POS_LE_NUMSEG"
-  "SUM_POS_LE" > "HOLLight.hollight.SUM_POS_LE"
-  "SUM_POS_EQ_0_NUMSEG" > "HOLLight.hollight.SUM_POS_EQ_0_NUMSEG"
-  "SUM_POS_EQ_0" > "HOLLight.hollight.SUM_POS_EQ_0"
-  "SUM_POS_BOUND" > "HOLLight.hollight.SUM_POS_BOUND"
-  "SUM_PARTIAL_SUC" > "HOLLight.hollight.SUM_PARTIAL_SUC"
-  "SUM_PARTIAL_PRE" > "HOLLight.hollight.SUM_PARTIAL_PRE"
-  "SUM_PAIR" > "HOLLight.hollight.SUM_PAIR"
-  "SUM_OFFSET_0" > "HOLLight.hollight.SUM_OFFSET_0"
-  "SUM_OFFSET" > "HOLLight.hollight.SUM_OFFSET"
-  "SUM_NEG" > "HOLLight.hollight.SUM_NEG"
-  "SUM_MULTICOUNT_GEN" > "HOLLight.hollight.SUM_MULTICOUNT_GEN"
-  "SUM_MULTICOUNT" > "HOLLight.hollight.SUM_MULTICOUNT"
-  "SUM_LT_ALL" > "HOLLight.hollight.SUM_LT_ALL"
-  "SUM_LT" > "HOLLight.hollight.SUM_LT"
-  "SUM_LMUL" > "HOLLight.hollight.SUM_LMUL"
-  "SUM_LE_NUMSEG" > "HOLLight.hollight.SUM_LE_NUMSEG"
-  "SUM_LE_INCLUDED" > "HOLLight.hollight.SUM_LE_INCLUDED"
-  "SUM_LE" > "HOLLight.hollight.SUM_LE"
-  "SUM_INJECTION" > "HOLLight.hollight.SUM_INJECTION"
-  "SUM_INCL_EXCL" > "HOLLight.hollight.SUM_INCL_EXCL"
-  "SUM_IMAGE_NONZERO" > "HOLLight.hollight.SUM_IMAGE_NONZERO"
-  "SUM_IMAGE_LE" > "HOLLight.hollight.SUM_IMAGE_LE"
-  "SUM_IMAGE_GEN" > "HOLLight.hollight.SUM_IMAGE_GEN"
-  "SUM_IMAGE" > "HOLLight.hollight.SUM_IMAGE"
-  "SUM_GROUP" > "HOLLight.hollight.SUM_GROUP"
-  "SUM_EQ_SUPERSET" > "HOLLight.hollight.SUM_EQ_SUPERSET"
-  "SUM_EQ_NUMSEG" > "HOLLight.hollight.SUM_EQ_NUMSEG"
-  "SUM_EQ_GENERAL_INVERSES" > "HOLLight.hollight.SUM_EQ_GENERAL_INVERSES"
-  "SUM_EQ_GENERAL" > "HOLLight.hollight.SUM_EQ_GENERAL"
-  "SUM_EQ_0_NUMSEG" > "HOLLight.hollight.SUM_EQ_0_NUMSEG"
-  "SUM_EQ_0" > "HOLLight.hollight.SUM_EQ_0"
-  "SUM_EQ" > "HOLLight.hollight.SUM_EQ"
-  "SUM_DIFFS_ALT" > "HOLLight.hollight.SUM_DIFFS_ALT"
-  "SUM_DIFFS" > "HOLLight.hollight.SUM_DIFFS"
-  "SUM_DIFF" > "HOLLight.hollight.SUM_DIFF"
-  "SUM_DELTA" > "HOLLight.hollight.SUM_DELTA"
-  "SUM_DELETE_CASES" > "HOLLight.hollight.SUM_DELETE_CASES"
-  "SUM_DELETE" > "HOLLight.hollight.SUM_DELETE"
-  "SUM_CONST_NUMSEG" > "HOLLight.hollight.SUM_CONST_NUMSEG"
-  "SUM_CONST" > "HOLLight.hollight.SUM_CONST"
-  "SUM_COMBINE_R" > "HOLLight.hollight.SUM_COMBINE_R"
-  "SUM_COMBINE_L" > "HOLLight.hollight.SUM_COMBINE_L"
-  "SUM_CLOSED" > "HOLLight.hollight.SUM_CLOSED"
-  "SUM_CLAUSES_RIGHT" > "HOLLight.hollight.SUM_CLAUSES_RIGHT"
-  "SUM_CLAUSES_NUMSEG" > "HOLLight.hollight.SUM_CLAUSES_NUMSEG"
-  "SUM_CLAUSES_LEFT" > "HOLLight.hollight.SUM_CLAUSES_LEFT"
-  "SUM_CLAUSES" > "HOLLight.hollight.SUM_CLAUSES"
-  "SUM_CASES_1" > "HOLLight.hollight.SUM_CASES_1"
-  "SUM_CASES" > "HOLLight.hollight.SUM_CASES"
-  "SUM_BOUND_LT_GEN" > "HOLLight.hollight.SUM_BOUND_LT_GEN"
-  "SUM_BOUND_LT_ALL" > "HOLLight.hollight.SUM_BOUND_LT_ALL"
-  "SUM_BOUND_LT" > "HOLLight.hollight.SUM_BOUND_LT"
-  "SUM_BOUND_GEN" > "HOLLight.hollight.SUM_BOUND_GEN"
-  "SUM_BOUND" > "HOLLight.hollight.SUM_BOUND"
-  "SUM_BIJECTION" > "HOLLight.hollight.SUM_BIJECTION"
-  "SUM_ADD_SPLIT" > "HOLLight.hollight.SUM_ADD_SPLIT"
-  "SUM_ADD_NUMSEG" > "HOLLight.hollight.SUM_ADD_NUMSEG"
-  "SUM_ADD_GEN" > "HOLLight.hollight.SUM_ADD_GEN"
-  "SUM_ADD" > "HOLLight.hollight.SUM_ADD"
-  "SUM_ABS_NUMSEG" > "HOLLight.hollight.SUM_ABS_NUMSEG"
-  "SUM_ABS_LE" > "HOLLight.hollight.SUM_ABS_LE"
-  "SUM_ABS_BOUND" > "HOLLight.hollight.SUM_ABS_BOUND"
-  "SUM_ABS" > "HOLLight.hollight.SUM_ABS"
-  "SUM_0" > "HOLLight.hollight.SUM_0"
-  "SUC_SUB1" > "Nat.diff_Suc_1"
-  "SUC_INJ" > "HOLLightCompat.SUC_INJ"
-  "SUB_SUC" > "Nat.diff_Suc_Suc"
-  "SUB_REFL" > "Nat.diff_self_eq_0"
-  "SUB_PRESUC" > "HOLLight.hollight.SUB_PRESUC"
-  "SUB_EQ_0" > "Nat.diff_is_0_eq"
-  "SUB_ELIM_THM" > "HOLLight.hollight.SUB_ELIM_THM"
-  "SUB_ADD_RCANCEL" > "Nat.diff_cancel2"
-  "SUB_ADD_LCANCEL" > "Nat.diff_cancel"
-  "SUB_ADD" > "Nat.le_add_diff_inverse2"
-  "SUB_0" > "HOLLight.hollight.SUB_0"
-  "SUBSET_UNIV" > "Orderings.top_class.top_greatest"
-  "SUBSET_UNION_ABSORPTION" > "Lattices.semilattice_sup_class.le_iff_sup"
-  "SUBSET_UNIONS" > "Complete_Lattices.Union_mono"
-  "SUBSET_UNION" > "HOLLight.hollight.SUBSET_UNION"
-  "SUBSET_TRANS" > "Orderings.order_trans_rules_23"
-  "SUBSET_RESTRICT" > "HOLLight.hollight.SUBSET_RESTRICT"
-  "SUBSET_REFL" > "Inductive.basic_monos_1"
-  "SUBSET_PSUBSET_TRANS" > "Orderings.order_le_less_trans"
-  "SUBSET_NUMSEG" > "HOLLight.hollight.SUBSET_NUMSEG"
-  "SUBSET_INTER_ABSORPTION" > "Lattices.semilattice_inf_class.le_iff_inf"
-  "SUBSET_INTER" > "Lattices.semilattice_inf_class.le_inf_iff"
-  "SUBSET_INSERT_DELETE" > "HOLLight.hollight.SUBSET_INSERT_DELETE"
-  "SUBSET_INSERT" > "Set.subset_insert"
-  "SUBSET_IMAGE" > "Set.subset_image_iff"
-  "SUBSET_EMPTY" > "Orderings.bot_class.bot_unique"
-  "SUBSET_DIFF" > "Set.Diff_subset"
-  "SUBSET_DELETE" > "HOLLight.hollight.SUBSET_DELETE"
-  "SUBSET_CARD_EQ" > "HOLLight.hollight.SUBSET_CARD_EQ"
-  "SUBSET_ANTISYM_EQ" > "Orderings.order_class.eq_iff"
-  "SUBSET_ANTISYM" > "Orderings.order_antisym"
-  "SND" > "Product_Type.snd_conv"
-  "SKOLEM_THM" > "HOLLight.hollight.SKOLEM_THM"
-  "SING_def" > "HOLLight.hollight.SING_def"
-  "SING_SUBSET" > "HOLLight.hollight.SING_SUBSET"
-  "SING_GSPEC" > "HOLLight.hollight.SING_GSPEC"
-  "SIMPLE_IMAGE_GEN" > "HOLLight.hollight.SIMPLE_IMAGE_GEN"
-  "SIMPLE_IMAGE" > "HOLLight.hollight.SIMPLE_IMAGE"
-  "SET_RECURSION_LEMMA" > "HOLLight.hollight.SET_RECURSION_LEMMA"
-  "SET_PROVE_CASES" > "HOLLight.hollight.SET_PROVE_CASES"
-  "SET_PAIR_THM" > "HOLLight.hollight.SET_PAIR_THM"
-  "SET_OF_LIST_MAP" > "List.set_map"
-  "SET_OF_LIST_EQ_EMPTY" > "List.set_empty"
-  "SET_OF_LIST_APPEND" > "List.set_append"
-  "SET_CASES" > "HOLLight.hollight.SET_CASES"
-  "SEMIRING_PTHS" > "HOLLight.hollight.SEMIRING_PTHS"
-  "SELECT_UNIQUE" > "HOLLight.hollight.SELECT_UNIQUE"
-  "SELECT_REFL" > "Hilbert_Choice.some_eq_trivial"
-  "SELECT_LEMMA" > "Hilbert_Choice.some_sym_eq_trivial"
-  "RIGHT_SUB_DISTRIB" > "Nat.diff_mult_distrib"
-  "RIGHT_OR_FORALL_THM" > "HOL.all_simps_4"
-  "RIGHT_OR_EXISTS_THM" > "HOL.ex_simps_4"
-  "RIGHT_OR_DISTRIB" > "Groebner_Basis.dnf_2"
-  "RIGHT_IMP_FORALL_THM" > "HOL.all_simps_6"
-  "RIGHT_IMP_EXISTS_THM" > "HOL.ex_simps_6"
-  "RIGHT_FORALL_OR_THM" > "HOL.all_simps_4"
-  "RIGHT_FORALL_IMP_THM" > "HOL.all_simps_6"
-  "RIGHT_EXISTS_IMP_THM" > "HOL.ex_simps_6"
-  "RIGHT_EXISTS_AND_THM" > "HOL.ex_simps_2"
-  "RIGHT_AND_FORALL_THM" > "HOL.all_simps_2"
-  "RIGHT_AND_EXISTS_THM" > "HOL.ex_simps_2"
-  "RIGHT_ADD_DISTRIB" > "Fields.linordered_field_class.sign_simps_26"
-  "REVERSE_REVERSE" > "List.rev_rev_ident"
-  "REVERSE_APPEND" > "List.rev_append"
-  "REST_def" > "HOLLight.hollight.REST_def"
-  "REFL_CLAUSE" > "Groebner_Basis.bool_simps_6"
-  "REAL_WLOG_LT" > "HOLLight.hollight.REAL_WLOG_LT"
-  "REAL_WLOG_LE" > "HOLLight.hollight.REAL_WLOG_LE"
-  "REAL_SUB_TRIANGLE" > "HOLLight.hollight.REAL_SUB_TRIANGLE"
-  "REAL_SUB_SUB2" > "HOLLight.hollight.REAL_SUB_SUB2"
-  "REAL_SUB_SUB" > "HOLLight.hollight.REAL_SUB_SUB"
-  "REAL_SUB_RZERO" > "HOLLight.hollight.REAL_SUB_RZERO"
-  "REAL_SUB_RNEG" > "HOLLight.hollight.REAL_SUB_RNEG"
-  "REAL_SUB_REFL" > "HOLLight.hollight.REAL_SUB_REFL"
-  "REAL_SUB_RDISTRIB" > "HOLLight.hollight.REAL_SUB_RDISTRIB"
-  "REAL_SUB_POW_R1" > "HOLLight.hollight.REAL_SUB_POW_R1"
-  "REAL_SUB_POW_L1" > "HOLLight.hollight.REAL_SUB_POW_L1"
-  "REAL_SUB_POW" > "HOLLight.hollight.REAL_SUB_POW"
-  "REAL_SUB_NEG2" > "HOLLight.hollight.REAL_SUB_NEG2"
-  "REAL_SUB_LZERO" > "HOLLight.hollight.REAL_SUB_LZERO"
-  "REAL_SUB_LT" > "HOLLight.hollight.REAL_SUB_LT"
-  "REAL_SUB_LNEG" > "HOLLight.hollight.REAL_SUB_LNEG"
-  "REAL_SUB_LE" > "HOLLight.hollight.REAL_SUB_LE"
-  "REAL_SUB_LDISTRIB" > "HOLLight.hollight.REAL_SUB_LDISTRIB"
-  "REAL_SUB_INV" > "HOLLight.hollight.REAL_SUB_INV"
-  "REAL_SUB_ADD2" > "HOLLight.hollight.REAL_SUB_ADD2"
-  "REAL_SUB_ADD" > "HOLLight.hollight.REAL_SUB_ADD"
-  "REAL_SUB_ABS" > "HOLLight.hollight.REAL_SUB_ABS"
-  "REAL_SUB_0" > "HOLLight.hollight.REAL_SUB_0"
-  "REAL_SOS_EQ_0" > "HOLLight.hollight.REAL_SOS_EQ_0"
-  "REAL_SGN_NEG" > "HOLLight.hollight.REAL_SGN_NEG"
-  "REAL_SGN_MUL" > "HOLLight.hollight.REAL_SGN_MUL"
-  "REAL_SGN_INV" > "HOLLight.hollight.REAL_SGN_INV"
-  "REAL_SGN_DIV" > "HOLLight.hollight.REAL_SGN_DIV"
-  "REAL_SGN_ABS" > "HOLLight.hollight.REAL_SGN_ABS"
-  "REAL_SGN_0" > "HOLLight.hollight.REAL_SGN_0"
-  "REAL_SGN" > "HOLLight.hollight.REAL_SGN"
-  "REAL_RNEG_UNIQ" > "HOLLight.hollight.REAL_RNEG_UNIQ"
-  "REAL_POW_ZERO" > "HOLLight.hollight.REAL_POW_ZERO"
-  "REAL_POW_SUB" > "HOLLight.hollight.REAL_POW_SUB"
-  "REAL_POW_POW" > "HOLLight.hollight.REAL_POW_POW"
-  "REAL_POW_ONE" > "HOLLight.hollight.REAL_POW_ONE"
-  "REAL_POW_NZ" > "HOLLight.hollight.REAL_POW_NZ"
-  "REAL_POW_NEG" > "HOLLight.hollight.REAL_POW_NEG"
-  "REAL_POW_MUL" > "HOLLight.hollight.REAL_POW_MUL"
-  "REAL_POW_MONO_LT" > "HOLLight.hollight.REAL_POW_MONO_LT"
-  "REAL_POW_MONO_INV" > "HOLLight.hollight.REAL_POW_MONO_INV"
-  "REAL_POW_MONO" > "HOLLight.hollight.REAL_POW_MONO"
-  "REAL_POW_LT_1" > "HOLLight.hollight.REAL_POW_LT_1"
-  "REAL_POW_LT2_REV" > "HOLLight.hollight.REAL_POW_LT2_REV"
-  "REAL_POW_LT2_ODD_EQ" > "HOLLight.hollight.REAL_POW_LT2_ODD_EQ"
-  "REAL_POW_LT2_ODD" > "HOLLight.hollight.REAL_POW_LT2_ODD"
-  "REAL_POW_LT2" > "HOLLight.hollight.REAL_POW_LT2"
-  "REAL_POW_LT" > "HOLLight.hollight.REAL_POW_LT"
-  "REAL_POW_LE_1" > "HOLLight.hollight.REAL_POW_LE_1"
-  "REAL_POW_LE2_REV" > "HOLLight.hollight.REAL_POW_LE2_REV"
-  "REAL_POW_LE2_ODD_EQ" > "HOLLight.hollight.REAL_POW_LE2_ODD_EQ"
-  "REAL_POW_LE2_ODD" > "HOLLight.hollight.REAL_POW_LE2_ODD"
-  "REAL_POW_LE2" > "HOLLight.hollight.REAL_POW_LE2"
-  "REAL_POW_LE" > "HOLLight.hollight.REAL_POW_LE"
-  "REAL_POW_INV" > "HOLLight.hollight.REAL_POW_INV"
-  "REAL_POW_EQ_ODD_EQ" > "HOLLight.hollight.REAL_POW_EQ_ODD_EQ"
-  "REAL_POW_EQ_ODD" > "HOLLight.hollight.REAL_POW_EQ_ODD"
-  "REAL_POW_EQ_EQ" > "HOLLight.hollight.REAL_POW_EQ_EQ"
-  "REAL_POW_EQ_ABS" > "HOLLight.hollight.REAL_POW_EQ_ABS"
-  "REAL_POW_EQ_1_IMP" > "HOLLight.hollight.REAL_POW_EQ_1_IMP"
-  "REAL_POW_EQ_1" > "HOLLight.hollight.REAL_POW_EQ_1"
-  "REAL_POW_EQ_0" > "HOLLight.hollight.REAL_POW_EQ_0"
-  "REAL_POW_EQ" > "HOLLight.hollight.REAL_POW_EQ"
-  "REAL_POW_DIV" > "HOLLight.hollight.REAL_POW_DIV"
-  "REAL_POW_ADD" > "HOLLight.hollight.REAL_POW_ADD"
-  "REAL_POW_2" > "HOLLight.hollight.REAL_POW_2"
-  "REAL_POW_1_LT" > "HOLLight.hollight.REAL_POW_1_LT"
-  "REAL_POW_1_LE" > "HOLLight.hollight.REAL_POW_1_LE"
-  "REAL_POW_1" > "HOLLight.hollight.REAL_POW_1"
-  "REAL_POW2_ABS" > "HOLLight.hollight.REAL_POW2_ABS"
-  "REAL_POS_NZ" > "HOLLight.hollight.REAL_POS_NZ"
-  "REAL_POS" > "HOLLight.hollight.REAL_POS"
-  "REAL_POLY_NEG_CLAUSES" > "HOLLight.hollight.REAL_POLY_NEG_CLAUSES"
-  "REAL_POLY_CLAUSES" > "HOLLight.hollight.REAL_POLY_CLAUSES"
-  "REAL_OF_NUM_SUM_NUMSEG" > "HOLLight.hollight.REAL_OF_NUM_SUM_NUMSEG"
-  "REAL_OF_NUM_SUM" > "HOLLight.hollight.REAL_OF_NUM_SUM"
-  "REAL_OF_NUM_SUC" > "HOLLight.hollight.REAL_OF_NUM_SUC"
-  "REAL_OF_NUM_SUB" > "HOLLight.hollight.REAL_OF_NUM_SUB"
-  "REAL_OF_NUM_POW" > "HOLLight.hollight.REAL_OF_NUM_POW"
-  "REAL_OF_NUM_MIN" > "HOLLight.hollight.REAL_OF_NUM_MIN"
-  "REAL_OF_NUM_MAX" > "HOLLight.hollight.REAL_OF_NUM_MAX"
-  "REAL_OF_NUM_LT" > "HOLLight.hollight.REAL_OF_NUM_LT"
-  "REAL_OF_NUM_GT" > "HOLLight.hollight.REAL_OF_NUM_GT"
-  "REAL_OF_NUM_GE" > "HOLLight.hollight.REAL_OF_NUM_GE"
-  "REAL_NOT_LT" > "HOLLight.hollight.REAL_NOT_LT"
-  "REAL_NOT_LE" > "HOLLight.hollight.real_lt_def"
-  "REAL_NOT_EQ" > "HOLLight.hollight.REAL_NOT_EQ"
-  "REAL_NEG_SUB" > "HOLLight.hollight.REAL_NEG_SUB"
-  "REAL_NEG_RMUL" > "HOLLight.hollight.REAL_NEG_RMUL"
-  "REAL_NEG_NEG" > "HOLLight.hollight.REAL_NEG_NEG"
-  "REAL_NEG_MUL2" > "HOLLight.hollight.REAL_NEG_MUL2"
-  "REAL_NEG_MINUS1" > "HOLLight.hollight.REAL_NEG_MINUS1"
-  "REAL_NEG_LT0" > "HOLLight.hollight.REAL_NEG_LT0"
-  "REAL_NEG_LMUL" > "HOLLight.hollight.REAL_NEG_LMUL"
-  "REAL_NEG_LE0" > "HOLLight.hollight.REAL_NEG_LE0"
-  "REAL_NEG_GT0" > "HOLLight.hollight.REAL_NEG_GT0"
-  "REAL_NEG_GE0" > "HOLLight.hollight.REAL_NEG_GE0"
-  "REAL_NEG_EQ_0" > "HOLLight.hollight.REAL_NEG_EQ_0"
-  "REAL_NEG_EQ" > "HOLLight.hollight.REAL_NEG_EQ"
-  "REAL_NEG_ADD" > "HOLLight.hollight.REAL_NEG_ADD"
-  "REAL_NEG_0" > "HOLLight.hollight.REAL_NEG_0"
-  "REAL_NEGNEG" > "HOLLight.hollight.REAL_NEGNEG"
-  "REAL_MUL_RZERO" > "HOLLight.hollight.REAL_MUL_RZERO"
-  "REAL_MUL_RNEG" > "HOLLight.hollight.REAL_MUL_RNEG"
-  "REAL_MUL_RINV_UNIQ" > "HOLLight.hollight.REAL_MUL_RINV_UNIQ"
-  "REAL_MUL_RINV" > "HOLLight.hollight.REAL_MUL_RINV"
-  "REAL_MUL_RID" > "HOLLight.hollight.REAL_MUL_RID"
-  "REAL_MUL_POS_LT" > "HOLLight.hollight.REAL_MUL_POS_LT"
-  "REAL_MUL_POS_LE" > "HOLLight.hollight.REAL_MUL_POS_LE"
-  "REAL_MUL_LZERO" > "HOLLight.hollight.REAL_MUL_LZERO"
-  "REAL_MUL_LNEG" > "HOLLight.hollight.REAL_MUL_LNEG"
-  "REAL_MUL_LINV_UNIQ" > "HOLLight.hollight.REAL_MUL_LINV_UNIQ"
-  "REAL_MUL_AC" > "HOLLight.hollight.REAL_MUL_AC"
-  "REAL_MUL_2" > "HOLLight.hollight.REAL_MUL_2"
-  "REAL_MIN_SYM" > "HOLLight.hollight.REAL_MIN_SYM"
-  "REAL_MIN_MIN" > "HOLLight.hollight.REAL_MIN_MIN"
-  "REAL_MIN_MAX" > "HOLLight.hollight.REAL_MIN_MAX"
-  "REAL_MIN_LT" > "HOLLight.hollight.REAL_MIN_LT"
-  "REAL_MIN_LE" > "HOLLight.hollight.REAL_MIN_LE"
-  "REAL_MIN_ASSOC" > "HOLLight.hollight.REAL_MIN_ASSOC"
-  "REAL_MIN_ACI" > "HOLLight.hollight.REAL_MIN_ACI"
-  "REAL_MAX_SYM" > "HOLLight.hollight.REAL_MAX_SYM"
-  "REAL_MAX_MIN" > "HOLLight.hollight.REAL_MAX_MIN"
-  "REAL_MAX_MAX" > "HOLLight.hollight.REAL_MAX_MAX"
-  "REAL_MAX_LT" > "HOLLight.hollight.REAL_MAX_LT"
-  "REAL_MAX_LE" > "HOLLight.hollight.REAL_MAX_LE"
-  "REAL_MAX_ASSOC" > "HOLLight.hollight.REAL_MAX_ASSOC"
-  "REAL_MAX_ACI" > "HOLLight.hollight.REAL_MAX_ACI"
-  "REAL_LT_TRANS" > "HOLLight.hollight.REAL_LT_TRANS"
-  "REAL_LT_TOTAL" > "HOLLight.hollight.REAL_LT_TOTAL"
-  "REAL_LT_SUB_RADD" > "HOLLight.hollight.REAL_LT_SUB_RADD"
-  "REAL_LT_SUB_LADD" > "HOLLight.hollight.REAL_LT_SUB_LADD"
-  "REAL_LT_SQUARE_ABS" > "HOLLight.hollight.REAL_LT_SQUARE_ABS"
-  "REAL_LT_SQUARE" > "HOLLight.hollight.REAL_LT_SQUARE"
-  "REAL_LT_RNEG" > "HOLLight.hollight.REAL_LT_RNEG"
-  "REAL_LT_RMUL_EQ" > "HOLLight.hollight.REAL_LT_RMUL_EQ"
-  "REAL_LT_RMUL" > "HOLLight.hollight.REAL_LT_RMUL"
-  "REAL_LT_RINV" > "HOLLight.hollight.REAL_LT_RINV"
-  "REAL_LT_REFL" > "HOLLight.hollight.REAL_LT_REFL"
-  "REAL_LT_RDIV_EQ" > "HOLLight.hollight.REAL_LT_RDIV_EQ"
-  "REAL_LT_RCANCEL_IMP" > "HOLLight.hollight.REAL_LT_RCANCEL_IMP"
-  "REAL_LT_RADD" > "HOLLight.hollight.REAL_LT_RADD"
-  "REAL_LT_POW2" > "HOLLight.hollight.REAL_LT_POW2"
-  "REAL_LT_NEGTOTAL" > "HOLLight.hollight.REAL_LT_NEGTOTAL"
-  "REAL_LT_NEG2" > "HOLLight.hollight.REAL_LT_NEG2"
-  "REAL_LT_NEG" > "HOLLight.hollight.REAL_LT_NEG"
-  "REAL_LT_MUL_EQ" > "HOLLight.hollight.REAL_LT_MUL_EQ"
-  "REAL_LT_MUL2" > "HOLLight.hollight.REAL_LT_MUL2"
-  "REAL_LT_MUL" > "HOLLight.hollight.REAL_LT_MUL"
-  "REAL_LT_MIN" > "HOLLight.hollight.REAL_LT_MIN"
-  "REAL_LT_MAX" > "HOLLight.hollight.REAL_LT_MAX"
-  "REAL_LT_LNEG" > "HOLLight.hollight.REAL_LT_LNEG"
-  "REAL_LT_LMUL_EQ" > "HOLLight.hollight.REAL_LT_LMUL_EQ"
-  "REAL_LT_LMUL" > "HOLLight.hollight.REAL_LT_LMUL"
-  "REAL_LT_LINV" > "HOLLight.hollight.REAL_LT_LINV"
-  "REAL_LT_LE" > "HOLLight.hollight.REAL_LT_LE"
-  "REAL_LT_LDIV_EQ" > "HOLLight.hollight.REAL_LT_LDIV_EQ"
-  "REAL_LT_LCANCEL_IMP" > "HOLLight.hollight.REAL_LT_LCANCEL_IMP"
-  "REAL_LT_LADD_IMP" > "HOLLight.hollight.REAL_LT_LADD_IMP"
-  "REAL_LT_LADD" > "HOLLight.hollight.REAL_LT_LADD"
-  "REAL_LT_INV_EQ" > "HOLLight.hollight.REAL_LT_INV_EQ"
-  "REAL_LT_INV2" > "HOLLight.hollight.REAL_LT_INV2"
-  "REAL_LT_INV" > "HOLLight.hollight.REAL_LT_INV"
-  "REAL_LT_IMP_NZ" > "HOLLight.hollight.REAL_LT_IMP_NZ"
-  "REAL_LT_IMP_NE" > "HOLLight.hollight.REAL_LT_IMP_NE"
-  "REAL_LT_IMP_LE" > "HOLLight.hollight.REAL_LT_IMP_LE"
-  "REAL_LT_GT" > "HOLLight.hollight.REAL_LT_GT"
-  "REAL_LT_DIV2_EQ" > "HOLLight.hollight.REAL_LT_DIV2_EQ"
-  "REAL_LT_DIV" > "HOLLight.hollight.REAL_LT_DIV"
-  "REAL_LT_ANTISYM" > "HOLLight.hollight.REAL_LT_ANTISYM"
-  "REAL_LT_ADD_SUB" > "HOLLight.hollight.REAL_LT_ADD_SUB"
-  "REAL_LT_ADDR" > "HOLLight.hollight.REAL_LT_ADDR"
-  "REAL_LT_ADDNEG2" > "HOLLight.hollight.REAL_LT_ADDNEG2"
-  "REAL_LT_ADDNEG" > "HOLLight.hollight.REAL_LT_ADDNEG"
-  "REAL_LT_ADDL" > "HOLLight.hollight.REAL_LT_ADDL"
-  "REAL_LT_ADD2" > "HOLLight.hollight.REAL_LT_ADD2"
-  "REAL_LT_ADD1" > "HOLLight.hollight.REAL_LT_ADD1"
-  "REAL_LT_ADD" > "HOLLight.hollight.REAL_LT_ADD"
-  "REAL_LT_01" > "HOLLight.hollight.REAL_LT_01"
-  "REAL_LTE_TRANS" > "HOLLight.hollight.REAL_LTE_TRANS"
-  "REAL_LTE_TOTAL" > "HOLLight.hollight.REAL_LTE_TOTAL"
-  "REAL_LTE_ANTISYM" > "HOLLight.hollight.REAL_LTE_ANTISYM"
-  "REAL_LTE_ADD2" > "HOLLight.hollight.REAL_LTE_ADD2"
-  "REAL_LTE_ADD" > "HOLLight.hollight.REAL_LTE_ADD"
-  "REAL_LNEG_UNIQ" > "HOLLight.hollight.REAL_LNEG_UNIQ"
-  "REAL_LE_SUB_RADD" > "HOLLight.hollight.REAL_LE_SUB_RADD"
-  "REAL_LE_SUB_LADD" > "HOLLight.hollight.REAL_LE_SUB_LADD"
-  "REAL_LE_SQUARE_ABS" > "HOLLight.hollight.REAL_LE_SQUARE_ABS"
-  "REAL_LE_SQUARE" > "HOLLight.hollight.REAL_LE_SQUARE"
-  "REAL_LE_RNEG" > "HOLLight.hollight.REAL_LE_RNEG"
-  "REAL_LE_RMUL_EQ" > "HOLLight.hollight.REAL_LE_RMUL_EQ"
-  "REAL_LE_RMUL" > "HOLLight.hollight.REAL_LE_RMUL"
-  "REAL_LE_RINV" > "HOLLight.hollight.REAL_LE_RINV"
-  "REAL_LE_RDIV_EQ" > "HOLLight.hollight.REAL_LE_RDIV_EQ"
-  "REAL_LE_RCANCEL_IMP" > "HOLLight.hollight.REAL_LE_RCANCEL_IMP"
-  "REAL_LE_RADD" > "HOLLight.hollight.REAL_LE_RADD"
-  "REAL_LE_POW_2" > "HOLLight.hollight.REAL_LE_POW_2"
-  "REAL_LE_POW2" > "HOLLight.hollight.REAL_LE_POW2"
-  "REAL_LE_NEGTOTAL" > "HOLLight.hollight.REAL_LE_NEGTOTAL"
-  "REAL_LE_NEGR" > "HOLLight.hollight.REAL_LE_NEGR"
-  "REAL_LE_NEGL" > "HOLLight.hollight.REAL_LE_NEGL"
-  "REAL_LE_NEG2" > "HOLLight.hollight.REAL_LE_NEG2"
-  "REAL_LE_NEG" > "HOLLight.hollight.REAL_LE_NEG"
-  "REAL_LE_MUL_EQ" > "HOLLight.hollight.REAL_LE_MUL_EQ"
-  "REAL_LE_MUL2" > "HOLLight.hollight.REAL_LE_MUL2"
-  "REAL_LE_MIN" > "HOLLight.hollight.REAL_LE_MIN"
-  "REAL_LE_MAX" > "HOLLight.hollight.REAL_LE_MAX"
-  "REAL_LE_LT" > "HOLLight.hollight.REAL_LE_LT"
-  "REAL_LE_LNEG" > "HOLLight.hollight.REAL_LE_LNEG"
-  "REAL_LE_LMUL_EQ" > "HOLLight.hollight.REAL_LE_LMUL_EQ"
-  "REAL_LE_LMUL" > "HOLLight.hollight.REAL_LE_LMUL"
-  "REAL_LE_LINV" > "HOLLight.hollight.REAL_LE_LINV"
-  "REAL_LE_LDIV_EQ" > "HOLLight.hollight.REAL_LE_LDIV_EQ"
-  "REAL_LE_LCANCEL_IMP" > "HOLLight.hollight.REAL_LE_LCANCEL_IMP"
-  "REAL_LE_LADD" > "HOLLight.hollight.REAL_LE_LADD"
-  "REAL_LE_INV_EQ" > "HOLLight.hollight.REAL_LE_INV_EQ"
-  "REAL_LE_INV2" > "HOLLight.hollight.REAL_LE_INV2"
-  "REAL_LE_INV" > "HOLLight.hollight.REAL_LE_INV"
-  "REAL_LE_DOUBLE" > "HOLLight.hollight.REAL_LE_DOUBLE"
-  "REAL_LE_DIV2_EQ" > "HOLLight.hollight.REAL_LE_DIV2_EQ"
-  "REAL_LE_DIV" > "HOLLight.hollight.REAL_LE_DIV"
-  "REAL_LE_ADDR" > "HOLLight.hollight.REAL_LE_ADDR"
-  "REAL_LE_ADDL" > "HOLLight.hollight.REAL_LE_ADDL"
-  "REAL_LE_ADD2" > "HOLLight.hollight.REAL_LE_ADD2"
-  "REAL_LE_ADD" > "HOLLight.hollight.REAL_LE_ADD"
-  "REAL_LE_01" > "HOLLight.hollight.REAL_LE_01"
-  "REAL_LET_TRANS" > "HOLLight.hollight.REAL_LET_TRANS"
-  "REAL_LET_TOTAL" > "HOLLight.hollight.REAL_LET_TOTAL"
-  "REAL_LET_ANTISYM" > "HOLLight.hollight.REAL_LET_ANTISYM"
-  "REAL_LET_ADD2" > "HOLLight.hollight.REAL_LET_ADD2"
-  "REAL_LET_ADD" > "HOLLight.hollight.REAL_LET_ADD"
-  "REAL_INV_POW" > "HOLLight.hollight.REAL_INV_POW"
-  "REAL_INV_NEG" > "HOLLight.hollight.REAL_INV_NEG"
-  "REAL_INV_MUL" > "HOLLight.hollight.REAL_INV_MUL"
-  "REAL_INV_LT_1" > "HOLLight.hollight.REAL_INV_LT_1"
-  "REAL_INV_LE_1" > "HOLLight.hollight.REAL_INV_LE_1"
-  "REAL_INV_INV" > "HOLLight.hollight.REAL_INV_INV"
-  "REAL_INV_EQ_1" > "HOLLight.hollight.REAL_INV_EQ_1"
-  "REAL_INV_EQ_0" > "HOLLight.hollight.REAL_INV_EQ_0"
-  "REAL_INV_DIV" > "HOLLight.hollight.REAL_INV_DIV"
-  "REAL_INV_1_LT" > "HOLLight.hollight.REAL_INV_1_LT"
-  "REAL_INV_1_LE" > "HOLLight.hollight.REAL_INV_1_LE"
-  "REAL_INV_1" > "HOLLight.hollight.REAL_INV_1"
-  "REAL_INTEGRAL" > "HOLLight.hollight.REAL_INTEGRAL"
-  "REAL_HREAL_LEMMA2" > "HOLLight.hollight.REAL_HREAL_LEMMA2"
-  "REAL_HREAL_LEMMA1" > "HOLLight.hollight.REAL_HREAL_LEMMA1"
-  "REAL_EQ_SUB_RADD" > "HOLLight.hollight.REAL_EQ_SUB_RADD"
-  "REAL_EQ_SUB_LADD" > "HOLLight.hollight.REAL_EQ_SUB_LADD"
-  "REAL_EQ_SQUARE_ABS" > "HOLLight.hollight.REAL_EQ_SQUARE_ABS"
-  "REAL_EQ_RDIV_EQ" > "HOLLight.hollight.REAL_EQ_RDIV_EQ"
-  "REAL_EQ_RCANCEL_IMP" > "HOLLight.hollight.REAL_EQ_RCANCEL_IMP"
-  "REAL_EQ_NEG2" > "HOLLight.hollight.REAL_EQ_NEG2"
-  "REAL_EQ_MUL_RCANCEL" > "HOLLight.hollight.REAL_EQ_MUL_RCANCEL"
-  "REAL_EQ_MUL_LCANCEL" > "HOLLight.hollight.REAL_EQ_MUL_LCANCEL"
-  "REAL_EQ_LDIV_EQ" > "HOLLight.hollight.REAL_EQ_LDIV_EQ"
-  "REAL_EQ_LCANCEL_IMP" > "HOLLight.hollight.REAL_EQ_LCANCEL_IMP"
-  "REAL_EQ_INV2" > "HOLLight.hollight.REAL_EQ_INV2"
-  "REAL_EQ_IMP_LE" > "HOLLight.hollight.REAL_EQ_IMP_LE"
-  "REAL_EQ_ADD_RCANCEL_0" > "HOLLight.hollight.REAL_EQ_ADD_RCANCEL_0"
-  "REAL_EQ_ADD_RCANCEL" > "HOLLight.hollight.REAL_EQ_ADD_RCANCEL"
-  "REAL_EQ_ADD_LCANCEL_0" > "HOLLight.hollight.REAL_EQ_ADD_LCANCEL_0"
-  "REAL_EQ_ADD_LCANCEL" > "HOLLight.hollight.REAL_EQ_ADD_LCANCEL"
-  "REAL_ENTIRE" > "HOLLight.hollight.REAL_ENTIRE"
-  "REAL_DOWN2" > "HOLLight.hollight.REAL_DOWN2"
-  "REAL_DOWN" > "HOLLight.hollight.REAL_DOWN"
-  "REAL_DIV_RMUL" > "HOLLight.hollight.REAL_DIV_RMUL"
-  "REAL_DIV_REFL" > "HOLLight.hollight.REAL_DIV_REFL"
-  "REAL_DIV_POW2_ALT" > "HOLLight.hollight.REAL_DIV_POW2_ALT"
-  "REAL_DIV_POW2" > "HOLLight.hollight.REAL_DIV_POW2"
-  "REAL_DIV_LMUL" > "HOLLight.hollight.REAL_DIV_LMUL"
-  "REAL_DIV_1" > "HOLLight.hollight.REAL_DIV_1"
-  "REAL_DIFFSQ" > "HOLLight.hollight.REAL_DIFFSQ"
-  "REAL_COMPLETE_SOMEPOS" > "HOLLight.hollight.REAL_COMPLETE_SOMEPOS"
-  "REAL_COMPLETE" > "HOLLight.hollight.REAL_COMPLETE"
-  "REAL_BOUNDS_LT" > "HOLLight.hollight.REAL_BOUNDS_LT"
-  "REAL_BOUNDS_LE" > "HOLLight.hollight.REAL_BOUNDS_LE"
-  "REAL_ADD_SUB2" > "HOLLight.hollight.REAL_ADD_SUB2"
-  "REAL_ADD_SUB" > "HOLLight.hollight.REAL_ADD_SUB"
-  "REAL_ADD_RINV" > "HOLLight.hollight.REAL_ADD_RINV"
-  "REAL_ADD_RID" > "HOLLight.hollight.REAL_ADD_RID"
-  "REAL_ADD_RDISTRIB" > "HOLLight.hollight.REAL_ADD_RDISTRIB"
-  "REAL_ADD_AC" > "HOLLight.hollight.REAL_ADD_AC"
-  "REAL_ADD2_SUB2" > "HOLLight.hollight.REAL_ADD2_SUB2"
-  "REAL_ABS_ZERO" > "HOLLight.hollight.REAL_ABS_ZERO"
-  "REAL_ABS_TRIANGLE_LT" > "HOLLight.hollight.REAL_ABS_TRIANGLE_LT"
-  "REAL_ABS_TRIANGLE_LE" > "HOLLight.hollight.REAL_ABS_TRIANGLE_LE"
-  "REAL_ABS_TRIANGLE" > "HOLLight.hollight.REAL_ABS_TRIANGLE"
-  "REAL_ABS_SUB_ABS" > "HOLLight.hollight.REAL_ABS_SUB_ABS"
-  "REAL_ABS_SUB" > "HOLLight.hollight.REAL_ABS_SUB"
-  "REAL_ABS_STILLNZ" > "HOLLight.hollight.REAL_ABS_STILLNZ"
-  "REAL_ABS_SIGN2" > "HOLLight.hollight.REAL_ABS_SIGN2"
-  "REAL_ABS_SIGN" > "HOLLight.hollight.REAL_ABS_SIGN"
-  "REAL_ABS_SGN" > "HOLLight.hollight.REAL_ABS_SGN"
-  "REAL_ABS_REFL" > "HOLLight.hollight.REAL_ABS_REFL"
-  "REAL_ABS_POW" > "HOLLight.hollight.REAL_ABS_POW"
-  "REAL_ABS_POS" > "HOLLight.hollight.REAL_ABS_POS"
-  "REAL_ABS_NZ" > "HOLLight.hollight.REAL_ABS_NZ"
-  "REAL_ABS_NUM" > "HOLLight.hollight.REAL_ABS_NUM"
-  "REAL_ABS_NEG" > "HOLLight.hollight.REAL_ABS_NEG"
-  "REAL_ABS_MUL" > "HOLLight.hollight.REAL_ABS_MUL"
-  "REAL_ABS_LE" > "HOLLight.hollight.REAL_ABS_LE"
-  "REAL_ABS_INV" > "HOLLight.hollight.REAL_ABS_INV"
-  "REAL_ABS_DIV" > "HOLLight.hollight.REAL_ABS_DIV"
-  "REAL_ABS_CIRCLE" > "HOLLight.hollight.REAL_ABS_CIRCLE"
-  "REAL_ABS_CASES" > "HOLLight.hollight.REAL_ABS_CASES"
-  "REAL_ABS_BOUNDS" > "HOLLight.hollight.REAL_ABS_BOUNDS"
-  "REAL_ABS_BOUND" > "HOLLight.hollight.REAL_ABS_BOUND"
-  "REAL_ABS_BETWEEN2" > "HOLLight.hollight.REAL_ABS_BETWEEN2"
-  "REAL_ABS_BETWEEN1" > "HOLLight.hollight.REAL_ABS_BETWEEN1"
-  "REAL_ABS_BETWEEN" > "HOLLight.hollight.REAL_ABS_BETWEEN"
-  "REAL_ABS_ABS" > "HOLLight.hollight.REAL_ABS_ABS"
-  "REAL_ABS_1" > "HOLLight.hollight.REAL_ABS_1"
-  "REAL_ABS_0" > "HOLLight.hollight.REAL_ABS_0"
-  "RAT_LEMMA5" > "HOLLight.hollight.RAT_LEMMA5"
-  "RAT_LEMMA4" > "HOLLight.hollight.RAT_LEMMA4"
-  "RAT_LEMMA3" > "HOLLight.hollight.RAT_LEMMA3"
-  "RAT_LEMMA2" > "HOLLight.hollight.RAT_LEMMA2"
-  "RAT_LEMMA1" > "HOLLight.hollight.RAT_LEMMA1"
-  "PSUBSET_UNIV" > "HOLLight.hollight.PSUBSET_UNIV"
-  "PSUBSET_TRANS" > "Orderings.order_less_trans"
-  "PSUBSET_SUBSET_TRANS" > "Orderings.order_less_le_trans"
-  "PSUBSET_MEMBER" > "HOLLight.hollight.PSUBSET_MEMBER"
-  "PSUBSET_IRREFL" > "Orderings.order_less_irrefl"
-  "PSUBSET_INSERT_SUBSET" > "HOLLight.hollight.PSUBSET_INSERT_SUBSET"
-  "PSUBSET_ALT" > "HOLLight.hollight.PSUBSET_ALT"
-  "PRE_ELIM_THM" > "HOLLight.hollight.PRE_ELIM_THM"
-  "POWERSET_CLAUSES" > "HOLLight.hollight.POWERSET_CLAUSES"
-  "PASSOC_def" > "HOLLight.hollight.PASSOC_def"
-  "PAIR_SURJECTIVE" > "Product_Type.prod.nchotomy"
-  "PAIR_EXISTS_THM" > "HOLLight.hollight.PAIR_EXISTS_THM"
-  "PAIR_EQ" > "Product_Type.Pair_eq"
-  "PAIRWISE_def" > "HOLLight.hollight.PAIRWISE_def"
-  "PAIRWISE_SING" > "HOLLight.hollight.PAIRWISE_SING"
-  "PAIRWISE_MONO" > "HOLLight.hollight.PAIRWISE_MONO"
-  "PAIRWISE_EMPTY" > "HOLLight.hollight.PAIRWISE_EMPTY"
-  "PAIR" > "HOLLightCompat.PAIR"
-  "OR_EXISTS_THM" > "HOL.ex_disj_distrib"
-  "OR_CLAUSES" > "HOLLight.hollight.OR_CLAUSES"
-  "ONE" > "Nat.One_nat_def"
-  "ODD_SUB" > "HOLLight.hollight.ODD_SUB"
-  "ODD_MULT" > "HOLLight.hollight.ODD_MULT"
-  "ODD_MOD" > "HOLLight.hollight.ODD_MOD"
-  "ODD_EXP" > "HOLLight.hollight.ODD_EXP"
-  "ODD_EXISTS" > "Parity.odd_Suc_mult_two_ex"
-  "ODD_DOUBLE" > "HOLLight.hollight.ODD_DOUBLE"
-  "ODD_ADD" > "Parity.odd_add"
-  "NUM_REP_def" > "HOLLight.hollight.NUM_REP_def"
-  "NUM_OF_INT_OF_NUM" > "HOLLight.hollight.NUM_OF_INT_OF_NUM"
-  "NUM_OF_INT" > "HOLLight.hollight.NUM_OF_INT"
-  "NUM_INTEGRAL_LEMMA" > "HOLLight.hollight.NUM_INTEGRAL_LEMMA"
-  "NUM_INTEGRAL" > "HOLLight.hollight.NUM_INTEGRAL"
-  "NUM_GCD" > "HOLLight.hollight.NUM_GCD"
-  "NUMSUM_def" > "HOLLight.hollight.NUMSUM_def"
-  "NUMSUM_INJ" > "HOLLight.hollight.NUMSUM_INJ"
-  "NUMSND_def" > "HOLLight.hollight.NUMSND_def"
-  "NUMSEG_SING" > "SetInterval.order_class.atLeastAtMost_singleton"
-  "NUMSEG_RREC" > "HOLLight.hollight.NUMSEG_RREC"
-  "NUMSEG_REC" > "SetInterval.atLeastAtMostSuc_conv"
-  "NUMSEG_OFFSET_IMAGE" > "SetInterval.image_add_atLeastAtMost"
-  "NUMSEG_LT" > "HOLLight.hollight.NUMSEG_LT"
-  "NUMSEG_LREC" > "HOLLight.hollight.NUMSEG_LREC"
-  "NUMSEG_LE" > "HOLLight.hollight.NUMSEG_LE"
-  "NUMSEG_EMPTY" > "HOLLight.hollight.NUMSEG_EMPTY"
-  "NUMSEG_COMBINE_R" > "HOLLight.hollight.NUMSEG_COMBINE_R"
-  "NUMSEG_COMBINE_L" > "HOLLight.hollight.NUMSEG_COMBINE_L"
-  "NUMSEG_CLAUSES" > "HOLLight.hollight.NUMSEG_CLAUSES"
-  "NUMSEG_ADD_SPLIT" > "HOLLight.hollight.NUMSEG_ADD_SPLIT"
-  "NUMRIGHT_def" > "HOLLight.hollight.NUMRIGHT_def"
-  "NUMPAIR_def" > "HOLLight.hollight.NUMPAIR_def"
-  "NUMPAIR_INJ_LEMMA" > "HOLLight.hollight.NUMPAIR_INJ_LEMMA"
-  "NUMPAIR_INJ" > "HOLLight.hollight.NUMPAIR_INJ"
-  "NUMLEFT_def" > "HOLLight.hollight.NUMLEFT_def"
-  "NUMFST_def" > "HOLLight.hollight.NUMFST_def"
-  "NSUM_UNION_RZERO" > "HOLLight.hollight.NSUM_UNION_RZERO"
-  "NSUM_UNION_NONZERO" > "HOLLight.hollight.NSUM_UNION_NONZERO"
-  "NSUM_UNION_LZERO" > "HOLLight.hollight.NSUM_UNION_LZERO"
-  "NSUM_UNION_EQ" > "HOLLight.hollight.NSUM_UNION_EQ"
-  "NSUM_UNIONS_NONZERO" > "HOLLight.hollight.NSUM_UNIONS_NONZERO"
-  "NSUM_UNION" > "HOLLight.hollight.NSUM_UNION"
-  "NSUM_TRIV_NUMSEG" > "HOLLight.hollight.NSUM_TRIV_NUMSEG"
-  "NSUM_SWAP_NUMSEG" > "HOLLight.hollight.NSUM_SWAP_NUMSEG"
-  "NSUM_SWAP" > "HOLLight.hollight.NSUM_SWAP"
-  "NSUM_SUPPORT" > "HOLLight.hollight.NSUM_SUPPORT"
-  "NSUM_SUPERSET" > "HOLLight.hollight.NSUM_SUPERSET"
-  "NSUM_SUBSET_SIMPLE" > "HOLLight.hollight.NSUM_SUBSET_SIMPLE"
-  "NSUM_SUBSET" > "HOLLight.hollight.NSUM_SUBSET"
-  "NSUM_SING_NUMSEG" > "HOLLight.hollight.NSUM_SING_NUMSEG"
-  "NSUM_SING" > "HOLLight.hollight.NSUM_SING"
-  "NSUM_RMUL" > "HOLLight.hollight.NSUM_RMUL"
-  "NSUM_RESTRICT_SET" > "HOLLight.hollight.NSUM_RESTRICT_SET"
-  "NSUM_RESTRICT" > "HOLLight.hollight.NSUM_RESTRICT"
-  "NSUM_POS_BOUND" > "HOLLight.hollight.NSUM_POS_BOUND"
-  "NSUM_PAIR" > "HOLLight.hollight.NSUM_PAIR"
-  "NSUM_OFFSET_0" > "HOLLight.hollight.NSUM_OFFSET_0"
-  "NSUM_OFFSET" > "HOLLight.hollight.NSUM_OFFSET"
-  "NSUM_NSUM_RESTRICT" > "HOLLight.hollight.NSUM_NSUM_RESTRICT"
-  "NSUM_NSUM_PRODUCT" > "HOLLight.hollight.NSUM_NSUM_PRODUCT"
-  "NSUM_MULTICOUNT_GEN" > "HOLLight.hollight.NSUM_MULTICOUNT_GEN"
-  "NSUM_MULTICOUNT" > "HOLLight.hollight.NSUM_MULTICOUNT"
-  "NSUM_LT_ALL" > "HOLLight.hollight.NSUM_LT_ALL"
-  "NSUM_LT" > "HOLLight.hollight.NSUM_LT"
-  "NSUM_LMUL" > "HOLLight.hollight.NSUM_LMUL"
-  "NSUM_LE_NUMSEG" > "HOLLight.hollight.NSUM_LE_NUMSEG"
-  "NSUM_LE" > "HOLLight.hollight.NSUM_LE"
-  "NSUM_INJECTION" > "HOLLight.hollight.NSUM_INJECTION"
-  "NSUM_INCL_EXCL" > "HOLLight.hollight.NSUM_INCL_EXCL"
-  "NSUM_IMAGE_NONZERO" > "HOLLight.hollight.NSUM_IMAGE_NONZERO"
-  "NSUM_IMAGE_GEN" > "HOLLight.hollight.NSUM_IMAGE_GEN"
-  "NSUM_IMAGE" > "HOLLight.hollight.NSUM_IMAGE"
-  "NSUM_GROUP" > "HOLLight.hollight.NSUM_GROUP"
-  "NSUM_EQ_SUPERSET" > "HOLLight.hollight.NSUM_EQ_SUPERSET"
-  "NSUM_EQ_NUMSEG" > "HOLLight.hollight.NSUM_EQ_NUMSEG"
-  "NSUM_EQ_GENERAL_INVERSES" > "HOLLight.hollight.NSUM_EQ_GENERAL_INVERSES"
-  "NSUM_EQ_GENERAL" > "HOLLight.hollight.NSUM_EQ_GENERAL"
-  "NSUM_EQ_0_NUMSEG" > "HOLLight.hollight.NSUM_EQ_0_NUMSEG"
-  "NSUM_EQ_0_IFF_NUMSEG" > "HOLLight.hollight.NSUM_EQ_0_IFF_NUMSEG"
-  "NSUM_EQ_0_IFF" > "HOLLight.hollight.NSUM_EQ_0_IFF"
-  "NSUM_EQ_0" > "HOLLight.hollight.NSUM_EQ_0"
-  "NSUM_EQ" > "HOLLight.hollight.NSUM_EQ"
-  "NSUM_DIFF" > "HOLLight.hollight.NSUM_DIFF"
-  "NSUM_DELTA" > "HOLLight.hollight.NSUM_DELTA"
-  "NSUM_DELETE" > "HOLLight.hollight.NSUM_DELETE"
-  "NSUM_CONST_NUMSEG" > "HOLLight.hollight.NSUM_CONST_NUMSEG"
-  "NSUM_CONST" > "HOLLight.hollight.NSUM_CONST"
-  "NSUM_CLOSED" > "HOLLight.hollight.NSUM_CLOSED"
-  "NSUM_CLAUSES_RIGHT" > "HOLLight.hollight.NSUM_CLAUSES_RIGHT"
-  "NSUM_CLAUSES_NUMSEG" > "HOLLight.hollight.NSUM_CLAUSES_NUMSEG"
-  "NSUM_CLAUSES_LEFT" > "HOLLight.hollight.NSUM_CLAUSES_LEFT"
-  "NSUM_CLAUSES" > "HOLLight.hollight.NSUM_CLAUSES"
-  "NSUM_CASES" > "HOLLight.hollight.NSUM_CASES"
-  "NSUM_BOUND_LT_GEN" > "HOLLight.hollight.NSUM_BOUND_LT_GEN"
-  "NSUM_BOUND_LT_ALL" > "HOLLight.hollight.NSUM_BOUND_LT_ALL"
-  "NSUM_BOUND_LT" > "HOLLight.hollight.NSUM_BOUND_LT"
-  "NSUM_BOUND_GEN" > "HOLLight.hollight.NSUM_BOUND_GEN"
-  "NSUM_BOUND" > "HOLLight.hollight.NSUM_BOUND"
-  "NSUM_BIJECTION" > "HOLLight.hollight.NSUM_BIJECTION"
-  "NSUM_ADD_SPLIT" > "HOLLight.hollight.NSUM_ADD_SPLIT"
-  "NSUM_ADD_NUMSEG" > "HOLLight.hollight.NSUM_ADD_NUMSEG"
-  "NSUM_ADD_GEN" > "HOLLight.hollight.NSUM_ADD_GEN"
-  "NSUM_ADD" > "HOLLight.hollight.NSUM_ADD"
-  "NSUM_0" > "HOLLight.hollight.NSUM_0"
-  "NOT_UNIV_PSUBSET" > "Orderings.top_class.not_top_less"
-  "NOT_SUC" > "Nat.Suc_not_Zero"
-  "NOT_PSUBSET_EMPTY" > "Orderings.bot_class.not_less_bot"
-  "NOT_ODD" > "HOLLight.hollight.NOT_ODD"
-  "NOT_LT" > "Orderings.linorder_class.not_less"
-  "NOT_LE" > "Orderings.linorder_class.not_le"
-  "NOT_IN_EMPTY" > "HOLLight.hollight.NOT_IN_EMPTY"
-  "NOT_INSERT_EMPTY" > "Set.insert_not_empty"
-  "NOT_FORALL_THM" > "HOL.not_all"
-  "NOT_EXISTS_THM" > "HOL.not_ex"
-  "NOT_EX" > "HOLLightList.NOT_EX"
-  "NOT_EVEN" > "HOLLight.hollight.NOT_EVEN"
-  "NOT_EQUAL_SETS" > "HOLLight.hollight.NOT_EQUAL_SETS"
-  "NOT_EMPTY_INSERT" > "Set.empty_not_insert"
-  "NOT_CONS_NIL" > "List.list.distinct_2"
-  "NOT_CLAUSES_WEAK" > "HOLLight.hollight.NOT_CLAUSES_WEAK"
-  "NOT_ALL" > "HOLLightList.NOT_ALL"
-  "NEUTRAL_REAL_MUL" > "HOLLight.hollight.NEUTRAL_REAL_MUL"
-  "NEUTRAL_REAL_ADD" > "HOLLight.hollight.NEUTRAL_REAL_ADD"
-  "NEUTRAL_MUL" > "HOLLight.hollight.NEUTRAL_MUL"
-  "NEUTRAL_ADD" > "HOLLight.hollight.NEUTRAL_ADD"
-  "NADD_UBOUND" > "HOLLight.hollight.NADD_UBOUND"
-  "NADD_SUC" > "HOLLight.hollight.NADD_SUC"
-  "NADD_RDISTRIB" > "HOLLight.hollight.NADD_RDISTRIB"
-  "NADD_OF_NUM_WELLDEF" > "HOLLight.hollight.NADD_OF_NUM_WELLDEF"
-  "NADD_OF_NUM_MUL" > "HOLLight.hollight.NADD_OF_NUM_MUL"
-  "NADD_OF_NUM_LE" > "HOLLight.hollight.NADD_OF_NUM_LE"
-  "NADD_OF_NUM_EQ" > "HOLLight.hollight.NADD_OF_NUM_EQ"
-  "NADD_OF_NUM_ADD" > "HOLLight.hollight.NADD_OF_NUM_ADD"
-  "NADD_OF_NUM" > "HOLLight.hollight.NADD_OF_NUM"
-  "NADD_NONZERO" > "HOLLight.hollight.NADD_NONZERO"
-  "NADD_MUL_WELLDEF_LEMMA" > "HOLLight.hollight.NADD_MUL_WELLDEF_LEMMA"
-  "NADD_MUL_WELLDEF" > "HOLLight.hollight.NADD_MUL_WELLDEF"
-  "NADD_MUL_SYM" > "HOLLight.hollight.NADD_MUL_SYM"
-  "NADD_MUL_LINV_LEMMA8" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA8"
-  "NADD_MUL_LINV_LEMMA7a" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA7a"
-  "NADD_MUL_LINV_LEMMA7" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA7"
-  "NADD_MUL_LINV_LEMMA6" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA6"
-  "NADD_MUL_LINV_LEMMA5" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA5"
-  "NADD_MUL_LINV_LEMMA4" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA4"
-  "NADD_MUL_LINV_LEMMA3" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA3"
-  "NADD_MUL_LINV_LEMMA2" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA2"
-  "NADD_MUL_LINV_LEMMA1" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA1"
-  "NADD_MUL_LINV_LEMMA0" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA0"
-  "NADD_MUL_LINV" > "HOLLight.hollight.NADD_MUL_LINV"
-  "NADD_MUL_LID" > "HOLLight.hollight.NADD_MUL_LID"
-  "NADD_MUL_ASSOC" > "HOLLight.hollight.NADD_MUL_ASSOC"
-  "NADD_MULTIPLICATIVE" > "HOLLight.hollight.NADD_MULTIPLICATIVE"
-  "NADD_MUL" > "HOLLight.hollight.NADD_MUL"
-  "NADD_LE_WELLDEF_LEMMA" > "HOLLight.hollight.NADD_LE_WELLDEF_LEMMA"
-  "NADD_LE_WELLDEF" > "HOLLight.hollight.NADD_LE_WELLDEF"
-  "NADD_LE_TRANS" > "HOLLight.hollight.NADD_LE_TRANS"
-  "NADD_LE_TOTAL_LEMMA" > "HOLLight.hollight.NADD_LE_TOTAL_LEMMA"
-  "NADD_LE_TOTAL" > "HOLLight.hollight.NADD_LE_TOTAL"
-  "NADD_LE_RMUL" > "HOLLight.hollight.NADD_LE_RMUL"
-  "NADD_LE_REFL" > "HOLLight.hollight.NADD_LE_REFL"
-  "NADD_LE_RADD" > "HOLLight.hollight.NADD_LE_RADD"
-  "NADD_LE_LMUL" > "HOLLight.hollight.NADD_LE_LMUL"
-  "NADD_LE_LADD" > "HOLLight.hollight.NADD_LE_LADD"
-  "NADD_LE_EXISTS" > "HOLLight.hollight.NADD_LE_EXISTS"
-  "NADD_LE_ANTISYM" > "HOLLight.hollight.NADD_LE_ANTISYM"
-  "NADD_LE_ADD" > "HOLLight.hollight.NADD_LE_ADD"
-  "NADD_LE_0" > "HOLLight.hollight.NADD_LE_0"
-  "NADD_LDISTRIB" > "HOLLight.hollight.NADD_LDISTRIB"
-  "NADD_LBOUND" > "HOLLight.hollight.NADD_LBOUND"
-  "NADD_INV_WELLDEF" > "HOLLight.hollight.NADD_INV_WELLDEF"
-  "NADD_INV_0" > "HOLLight.hollight.NADD_INV_0"
-  "NADD_INV" > "HOLLight.hollight.NADD_INV"
-  "NADD_EQ_TRANS" > "HOLLight.hollight.NADD_EQ_TRANS"
-  "NADD_EQ_SYM" > "HOLLight.hollight.NADD_EQ_SYM"
-  "NADD_EQ_REFL" > "HOLLight.hollight.NADD_EQ_REFL"
-  "NADD_EQ_IMP_LE" > "HOLLight.hollight.NADD_EQ_IMP_LE"
-  "NADD_DIST_LEMMA" > "HOLLight.hollight.NADD_DIST_LEMMA"
-  "NADD_DIST" > "HOLLight.hollight.NADD_DIST"
-  "NADD_COMPLETE" > "HOLLight.hollight.NADD_COMPLETE"
-  "NADD_CAUCHY" > "HOLLight.hollight.NADD_CAUCHY"
-  "NADD_BOUND" > "HOLLight.hollight.NADD_BOUND"
-  "NADD_ARCH_ZERO" > "HOLLight.hollight.NADD_ARCH_ZERO"
-  "NADD_ARCH_MULT" > "HOLLight.hollight.NADD_ARCH_MULT"
-  "NADD_ARCH_LEMMA" > "HOLLight.hollight.NADD_ARCH_LEMMA"
-  "NADD_ARCH" > "HOLLight.hollight.NADD_ARCH"
-  "NADD_ALTMUL" > "HOLLight.hollight.NADD_ALTMUL"
-  "NADD_ADD_WELLDEF" > "HOLLight.hollight.NADD_ADD_WELLDEF"
-  "NADD_ADD_SYM" > "HOLLight.hollight.NADD_ADD_SYM"
-  "NADD_ADD_LID" > "HOLLight.hollight.NADD_ADD_LID"
-  "NADD_ADD_LCANCEL" > "HOLLight.hollight.NADD_ADD_LCANCEL"
-  "NADD_ADD_ASSOC" > "HOLLight.hollight.NADD_ADD_ASSOC"
-  "NADD_ADDITIVE" > "HOLLight.hollight.NADD_ADDITIVE"
-  "NADD_ADD" > "HOLLight.hollight.NADD_ADD"
-  "MULT_SYM" > "Fields.linordered_field_class.sign_simps_40"
-  "MULT_SUC" > "Nat.mult_Suc_right"
-  "MULT_EXP" > "Power.comm_monoid_mult_class.power_mult_distrib"
-  "MULT_EQ_1" > "Nat.nat_mult_eq_1_iff"
-  "MULT_EQ_0" > "Nat.mult_is_0"
-  "MULT_DIV_LE" > "HOLLight.hollight.MULT_DIV_LE"
-  "MULT_CLAUSES" > "HOLLight.hollight.MULT_CLAUSES"
-  "MULT_ASSOC" > "Fields.linordered_field_class.sign_simps_41"
-  "MULT_AC" > "HOLLight.hollight.MULT_AC"
-  "MULT_2" > "Int.semiring_mult_2"
-  "MULT_0" > "Divides.arithmetic_simps_41"
-  "MONO_FORALL" > "Inductive.basic_monos_6"
-  "MONO_EXISTS" > "Inductive.basic_monos_5"
-  "MONO_COND" > "HOLLight.hollight.MONO_COND"
-  "MONO_ALL2" > "List.list_all2_mono"
-  "MONO_ALL" > "HOLLightList.MONO_ALL"
-  "MONOIDAL_REAL_MUL" > "HOLLight.hollight.MONOIDAL_REAL_MUL"
-  "MONOIDAL_REAL_ADD" > "HOLLight.hollight.MONOIDAL_REAL_ADD"
-  "MONOIDAL_MUL" > "HOLLight.hollight.MONOIDAL_MUL"
-  "MONOIDAL_ADD" > "HOLLight.hollight.MONOIDAL_ADD"
-  "MONOIDAL_AC" > "HOLLight.hollight.MONOIDAL_AC"
-  "MOD_UNIQ" > "HOLLight.hollight.MOD_UNIQ"
-  "MOD_MULT_RMOD" > "HOLLight.hollight.MOD_MULT_RMOD"
-  "MOD_MULT_MOD2" > "HOLLight.hollight.MOD_MULT_MOD2"
-  "MOD_MULT_LMOD" > "HOLLight.hollight.MOD_MULT_LMOD"
-  "MOD_MULT_ADD" > "Divides.mod_mult_self3"
-  "MOD_MULT2" > "HOLLight.hollight.MOD_MULT2"
-  "MOD_MOD_REFL" > "HOLLight.hollight.MOD_MOD_REFL"
-  "MOD_MOD" > "HOLLight.hollight.MOD_MOD"
-  "MOD_LT" > "Divides.mod_less"
-  "MOD_LE" > "HOLLight.hollight.MOD_LE"
-  "MOD_EXP_MOD" > "HOLLight.hollight.MOD_EXP_MOD"
-  "MOD_EXISTS" > "HOLLight.hollight.MOD_EXISTS"
-  "MOD_EQ_0" > "HOLLight.hollight.MOD_EQ_0"
-  "MOD_EQ" > "HOLLight.hollight.MOD_EQ"
-  "MOD_ADD_MOD" > "HOLLight.hollight.MOD_ADD_MOD"
-  "MK_REC_INJ" > "HOLLight.hollight.MK_REC_INJ"
-  "MINIMAL" > "HOLLight.hollight.MINIMAL"
-  "MEM_MAP" > "HOLLightList.MEM_MAP"
-  "MEM_FILTER" > "HOLLightList.MEM_FILTER"
-  "MEM_EXISTS_EL" > "HOLLightList.MEM_EXISTS_EL"
-  "MEM_EL" > "List.nth_mem"
-  "MEM_APPEND" > "HOLLightList.MEM_APPEND"
-  "MEMBER_NOT_EMPTY" > "Set.ex_in_conv"
-  "MEASURE_LE" > "HOLLight.hollight.MEASURE_LE"
-  "MATCH_SEQPATTERN" > "HOLLight.hollight.MATCH_SEQPATTERN"
-  "MAP_o" > "List.map.compositionality"
-  "MAP_SND_ZIP" > "List.map_snd_zip"
-  "MAP_ID" > "List.map_ident"
-  "MAP_I" > "List.map.id"
-  "MAP_FST_ZIP" > "List.map_fst_zip"
-  "MAP_EQ_NIL" > "List.map_is_Nil_conv"
-  "MAP_EQ_DEGEN" > "HOLLightList.MAP_EQ_DEGEN"
-  "MAP_EQ_ALL2" > "HOLLightList.MAP_EQ_ALL2"
-  "MAP_EQ" > "HOLLightList.MAP_EQ"
-  "MAP_APPEND" > "List.map_append"
-  "MAP2" > "HOLLightList.MAP2"
-  "LT_TRANS" > "Orderings.order_less_trans"
-  "LT_SUC_LE" > "Nat.le_simps_2"
-  "LT_SUC" > "Nat.Suc_less_eq"
-  "LT_REFL" > "Nat.less_not_refl"
-  "LT_NZ" > "Nat.neq0_conv"
-  "LT_MULT_RCANCEL" > "HOLLight.hollight.LT_MULT_RCANCEL"
-  "LT_MULT_LCANCEL" > "HOLLight.hollight.LT_MULT_LCANCEL"
-  "LT_MULT2" > "HOLLight.hollight.LT_MULT2"
-  "LT_MULT" > "Nat.nat_0_less_mult_iff"
-  "LT_LMULT" > "HOLLight.hollight.LT_LMULT"
-  "LT_LE" > "Nat.nat_less_le"
-  "LT_IMP_LE" > "FunDef.termination_basic_simps_5"
-  "LT_EXP" > "HOLLight.hollight.LT_EXP"
-  "LT_EXISTS" > "HOLLight.hollight.LT_EXISTS"
-  "LT_CASES" > "HOLLight.hollight.LT_CASES"
-  "LT_ANTISYM" > "HOLLight.hollight.LT_ANTISYM"
-  "LT_ADD_RCANCEL" > "Groups.ordered_ab_semigroup_add_imp_le_class.add_less_cancel_right"
-  "LT_ADD_LCANCEL" > "Groups.ordered_ab_semigroup_add_imp_le_class.add_less_cancel_left"
-  "LT_ADDR" > "HOLLight.hollight.LT_ADDR"
-  "LT_ADD2" > "Groups.add_mono_thms_linordered_field_5"
-  "LT_ADD" > "HOLLight.hollight.LT_ADD"
-  "LT_0" > "Nat.zero_less_Suc"
-  "LTE_TRANS" > "Orderings.order_less_le_trans"
-  "LTE_CASES" > "HOLLight.hollight.LTE_CASES"
-  "LTE_ANTISYM" > "HOLLight.hollight.LTE_ANTISYM"
-  "LTE_ADD2" > "Groups.add_mono_thms_linordered_field_3"
-  "LE_TRANS" > "Nat.le_trans"
-  "LE_SUC_LT" > "Nat.Suc_le_eq"
-  "LE_SUC" > "Nat.Suc_le_mono"
-  "LE_SQUARE_REFL" > "Nat.le_square"
-  "LE_REFL" > "Nat.le_refl"
-  "LE_RDIV_EQ" > "HOLLight.hollight.LE_RDIV_EQ"
-  "LE_MULT_RCANCEL" > "HOLLight.hollight.LE_MULT_RCANCEL"
-  "LE_MULT_LCANCEL" > "HOLLight.hollight.LE_MULT_LCANCEL"
-  "LE_MULT2" > "Nat.mult_le_mono"
-  "LE_LT" > "Nat.le_eq_less_or_eq"
-  "LE_LDIV_EQ" > "HOLLight.hollight.LE_LDIV_EQ"
-  "LE_LDIV" > "HOLLight.hollight.LE_LDIV"
-  "LE_EXP" > "HOLLight.hollight.LE_EXP"
-  "LE_EXISTS" > "Nat.le_iff_add"
-  "LE_CASES" > "Nat.nat_le_linear"
-  "LE_C" > "HOLLight.hollight.LE_C"
-  "LE_ANTISYM" > "Orderings.order_class.eq_iff"
-  "LE_ADD_RCANCEL" > "Groups.ordered_ab_semigroup_add_imp_le_class.add_le_cancel_right"
-  "LE_ADD_LCANCEL" > "Groups.ordered_ab_semigroup_add_imp_le_class.add_le_cancel_left"
-  "LE_ADDR" > "Nat.le_add2"
-  "LE_ADD2" > "Groups.add_mono_thms_linordered_semiring_1"
-  "LE_ADD" > "Nat.le_add1"
-  "LE_1" > "HOLLight.hollight.LE_1"
-  "LE_0" > "Nat.le0"
-  "LET_TRANS" > "Orderings.order_le_less_trans"
-  "LET_END_def" > "HOLLight.hollight.LET_END_def"
-  "LET_CASES" > "Orderings.linorder_class.le_less_linear"
-  "LET_ANTISYM" > "HOLLight.hollight.LET_ANTISYM"
-  "LET_ADD2" > "Groups.add_mono_thms_linordered_field_4"
-  "LENGTH_TL" > "HOLLightList.LENGTH_TL"
-  "LENGTH_REPLICATE" > "List.length_replicate"
-  "LENGTH_MAP2" > "HOLLightList.LENGTH_MAP2"
-  "LENGTH_MAP" > "List.length_map"
-  "LENGTH_EQ_NIL" > "List.length_0_conv"
-  "LENGTH_EQ_CONS" > "List.length_Suc_conv"
-  "LENGTH_APPEND" > "List.length_append"
-  "LEFT_SUB_DISTRIB" > "Nat.diff_mult_distrib2"
-  "LEFT_OR_FORALL_THM" > "HOL.all_simps_3"
-  "LEFT_OR_EXISTS_THM" > "HOL.ex_simps_3"
-  "LEFT_OR_DISTRIB" > "Groebner_Basis.dnf_1"
-  "LEFT_IMP_FORALL_THM" > "HOL.ex_simps_5"
-  "LEFT_IMP_EXISTS_THM" > "HOL.all_simps_5"
-  "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_FORALL_THM" > "HOL.all_simps_1"
-  "LEFT_AND_EXISTS_THM" > "HOL.ex_simps_1"
-  "LEFT_ADD_DISTRIB" > "Fields.linordered_field_class.sign_simps_25"
-  "LAST_EL" > "List.last_conv_nth"
-  "LAST_CLAUSES" > "HOLLightList.LAST_CLAUSES"
-  "LAST_APPEND" > "List.last_append"
-  "LAMBDA_UNIQUE" > "HOLLight.hollight.LAMBDA_UNIQUE"
-  "LAMBDA_PAIR_THM" > "HOLLight.hollight.LAMBDA_PAIR_THM"
-  "LAMBDA_ETA" > "HOLLight.hollight.LAMBDA_ETA"
-  "LAMBDA_BETA" > "HOLLight.hollight.LAMBDA_BETA"
-  "I_THM" > "HOL.refl"
-  "I_O_ID" > "HOLLight.hollight.I_O_ID"
-  "ITSET_def" > "HOLLight.hollight.ITSET_def"
-  "ITSET_EQ" > "HOLLight.hollight.ITSET_EQ"
-  "ITLIST_EXTRA" > "HOLLightList.ITLIST_EXTRA"
-  "ITLIST_APPEND" > "List.foldr_append"
-  "ITLIST2" > "HOLLightList.ITLIST2"
-  "ITERATE_UNION_NONZERO" > "HOLLight.hollight.ITERATE_UNION_NONZERO"
-  "ITERATE_UNION_GEN" > "HOLLight.hollight.ITERATE_UNION_GEN"
-  "ITERATE_UNION" > "HOLLight.hollight.ITERATE_UNION"
-  "ITERATE_SUPPORT" > "HOLLight.hollight.ITERATE_SUPPORT"
-  "ITERATE_SUPERSET" > "HOLLight.hollight.ITERATE_SUPERSET"
-  "ITERATE_SING" > "HOLLight.hollight.ITERATE_SING"
-  "ITERATE_RELATED" > "HOLLight.hollight.ITERATE_RELATED"
-  "ITERATE_PAIR" > "HOLLight.hollight.ITERATE_PAIR"
-  "ITERATE_OP_GEN" > "HOLLight.hollight.ITERATE_OP_GEN"
-  "ITERATE_OP" > "HOLLight.hollight.ITERATE_OP"
-  "ITERATE_ITERATE_PRODUCT" > "HOLLight.hollight.ITERATE_ITERATE_PRODUCT"
-  "ITERATE_INJECTION" > "HOLLight.hollight.ITERATE_INJECTION"
-  "ITERATE_INCL_EXCL" > "HOLLight.hollight.ITERATE_INCL_EXCL"
-  "ITERATE_IMAGE_NONZERO" > "HOLLight.hollight.ITERATE_IMAGE_NONZERO"
-  "ITERATE_IMAGE" > "HOLLight.hollight.ITERATE_IMAGE"
-  "ITERATE_EXPAND_CASES" > "HOLLight.hollight.ITERATE_EXPAND_CASES"
-  "ITERATE_EQ_NEUTRAL" > "HOLLight.hollight.ITERATE_EQ_NEUTRAL"
-  "ITERATE_EQ_GENERAL_INVERSES" > "HOLLight.hollight.ITERATE_EQ_GENERAL_INVERSES"
-  "ITERATE_EQ_GENERAL" > "HOLLight.hollight.ITERATE_EQ_GENERAL"
-  "ITERATE_EQ" > "HOLLight.hollight.ITERATE_EQ"
-  "ITERATE_DIFF_GEN" > "HOLLight.hollight.ITERATE_DIFF_GEN"
-  "ITERATE_DIFF" > "HOLLight.hollight.ITERATE_DIFF"
-  "ITERATE_DELTA" > "HOLLight.hollight.ITERATE_DELTA"
-  "ITERATE_DELETE" > "HOLLight.hollight.ITERATE_DELETE"
-  "ITERATE_CLOSED" > "HOLLight.hollight.ITERATE_CLOSED"
-  "ITERATE_CLAUSES_NUMSEG" > "HOLLight.hollight.ITERATE_CLAUSES_NUMSEG"
-  "ITERATE_CLAUSES_GEN" > "HOLLight.hollight.ITERATE_CLAUSES_GEN"
-  "ITERATE_CLAUSES" > "HOLLight.hollight.ITERATE_CLAUSES"
-  "ITERATE_CASES" > "HOLLight.hollight.ITERATE_CASES"
-  "ITERATE_BIJECTION" > "HOLLight.hollight.ITERATE_BIJECTION"
-  "ISO_def" > "HOLLight.hollight.ISO_def"
-  "ISO_USAGE" > "HOLLight.hollight.ISO_USAGE"
-  "ISO_REFL" > "HOLLight.hollight.ISO_REFL"
-  "ISO_FUN" > "HOLLight.hollight.ISO_FUN"
-  "IN_UNIV" > "Set.UNIV_I"
-  "IN_UNIONS" > "HOLLight.hollight.IN_UNIONS"
-  "IN_UNION" > "Complete_Lattices.mem_simps_3"
-  "IN_SUPPORT" > "HOLLight.hollight.IN_SUPPORT"
-  "IN_SING" > "Set.singleton_iff"
-  "IN_SET_OF_LIST" > "HOLLightList.IN_SET_OF_LIST"
-  "IN_REST" > "HOLLight.hollight.IN_REST"
-  "IN_NUMSEG_0" > "HOLLight.hollight.IN_NUMSEG_0"
-  "IN_NUMSEG" > "SetInterval.ord_class.atLeastAtMost_iff"
-  "IN_INTERS" > "HOLLight.hollight.IN_INTERS"
-  "IN_INTER" > "Complete_Lattices.mem_simps_4"
-  "IN_INSERT" > "Complete_Lattices.mem_simps_1"
-  "IN_IMAGE" > "HOLLight.hollight.IN_IMAGE"
-  "IN_ELIM_THM" > "HOLLight.hollight.IN_ELIM_THM"
-  "IN_ELIM_PAIR_THM" > "HOLLight.hollight.IN_ELIM_PAIR_THM"
-  "IN_DISJOINT" > "HOLLight.hollight.IN_DISJOINT"
-  "IN_DIFF" > "Complete_Lattices.mem_simps_6"
-  "IN_DELETE_EQ" > "HOLLight.hollight.IN_DELETE_EQ"
-  "IN_DELETE" > "HOLLight.hollight.IN_DELETE"
-  "IN_CROSS" > "HOLLight.hollight.IN_CROSS"
-  "INT_WOP" > "HOLLight.hollight.INT_WOP"
-  "INT_POW" > "HOLLight.hollight.INT_POW"
-  "INT_OF_NUM_OF_INT" > "HOLLight.hollight.INT_OF_NUM_OF_INT"
-  "INT_LT_DISCRETE" > "HOLLight.hollight.INT_LT_DISCRETE"
-  "INT_LT" > "HOLLight.hollight.INT_LT"
-  "INT_INTEGRAL" > "HOLLight.hollight.INT_INTEGRAL"
-  "INT_IMAGE" > "HOLLight.hollight.INT_IMAGE"
-  "INT_GT_DISCRETE" > "HOLLight.hollight.INT_GT_DISCRETE"
-  "INT_GT" > "HOLLight.hollight.INT_GT"
-  "INT_GE" > "HOLLight.hollight.INT_GE"
-  "INT_GCD_EXISTS_POS" > "HOLLight.hollight.INT_GCD_EXISTS_POS"
-  "INT_GCD_EXISTS" > "HOLLight.hollight.INT_GCD_EXISTS"
-  "INT_FORALL_POS" > "HOLLight.hollight.INT_FORALL_POS"
-  "INT_FORALL_ABS" > "HOLLight.hollight.INT_FORALL_ABS"
-  "INT_EXISTS_POS" > "HOLLight.hollight.INT_EXISTS_POS"
-  "INT_EXISTS_ABS" > "HOLLight.hollight.INT_EXISTS_ABS"
-  "INT_DIVMOD_UNIQ" > "HOLLight.hollight.INT_DIVMOD_UNIQ"
-  "INT_DIVMOD_EXIST_0" > "HOLLight.hollight.INT_DIVMOD_EXIST_0"
-  "INT_DIVISION" > "HOLLight.hollight.INT_DIVISION"
-  "INT_ARCH" > "HOLLight.hollight.INT_ARCH"
-  "INT_ABS_MUL_1" > "HOLLight.hollight.INT_ABS_MUL_1"
-  "INT_ABS" > "HOLLight.hollight.INT_ABS"
-  "INTER_UNIV" > "HOLLight.hollight.INTER_UNIV"
-  "INTER_UNIONS" > "HOLLight.hollight.INTER_UNIONS"
-  "INTER_SUBSET" > "HOLLight.hollight.INTER_SUBSET"
-  "INTER_OVER_UNION" > "Lattices.distrib_lattice_class.distrib_1"
-  "INTER_IDEMPOT" > "Big_Operators.lattice_class.Inf_fin.idem"
-  "INTER_EMPTY" > "HOLLight.hollight.INTER_EMPTY"
-  "INTER_COMM" > "Lattices.lattice_class.inf_sup_aci_1"
-  "INTER_ASSOC" > "Lattices.lattice_class.inf_sup_aci_2"
-  "INTER_ACI" > "HOLLight.hollight.INTER_ACI"
-  "INTERS_UNIONS" > "HOLLight.hollight.INTERS_UNIONS"
-  "INTERS_INSERT" > "Complete_Lattices.Inter_insert"
-  "INTERS_IMAGE" > "HOLLight.hollight.INTERS_IMAGE"
-  "INTERS_GSPEC" > "HOLLight.hollight.INTERS_GSPEC"
-  "INTERS_2" > "Complete_Lattices.Int_eq_Inter"
-  "INTERS_1" > "Complete_Lattices.complete_lattice_class.Inf_singleton"
-  "INTERS_0" > "Complete_Lattices.Inter_empty"
-  "INSERT_UNIV" > "HOLLight.hollight.INSERT_UNIV"
-  "INSERT_UNION_EQ" > "Set.Un_insert_left"
-  "INSERT_UNION" > "HOLLight.hollight.INSERT_UNION"
-  "INSERT_SUBSET" > "Set.insert_subset"
-  "INSERT_INTER" > "Set.Int_insert_left"
-  "INSERT_INSERT" > "Set.insert_absorb2"
-  "INSERT_DIFF" > "Set.insert_Diff_if"
-  "INSERT_DELETE" > "Set.insert_Diff"
-  "INSERT_COMM" > "Set.insert_commute"
-  "INSERT_AC" > "HOLLight.hollight.INSERT_AC"
-  "INSERT" > "HOLLight.hollight.INSERT"
-  "INJ_def" > "HOLLight.hollight.INJ_def"
-  "INJ_INVERSE2" > "HOLLight.hollight.INJ_INVERSE2"
-  "INJP_def" > "HOLLight.hollight.INJP_def"
-  "INJP_INJ" > "HOLLight.hollight.INJP_INJ"
-  "INJN_def" > "HOLLight.hollight.INJN_def"
-  "INJN_INJ" > "HOLLight.hollight.INJN_INJ"
-  "INJF_def" > "HOLLight.hollight.INJF_def"
-  "INJF_INJ" > "HOLLight.hollight.INJF_INJ"
-  "INJECTIVE_ON_LEFT_INVERSE" > "HOLLight.hollight.INJECTIVE_ON_LEFT_INVERSE"
-  "INJECTIVE_ON_IMAGE" > "HOLLight.hollight.INJECTIVE_ON_IMAGE"
-  "INJECTIVE_MAP" > "HOLLightList.INJECTIVE_MAP"
-  "INJECTIVE_LEFT_INVERSE" > "HOLLight.hollight.INJECTIVE_LEFT_INVERSE"
-  "INJECTIVE_IMAGE" > "HOLLight.hollight.INJECTIVE_IMAGE"
-  "INJA_def" > "HOLLight.hollight.INJA_def"
-  "INJA_INJ" > "HOLLight.hollight.INJA_INJ"
-  "INFINITE_NONEMPTY" > "Infinite_Set.infinite_imp_nonempty"
-  "INFINITE_IMAGE_INJ" > "HOLLight.hollight.INFINITE_IMAGE_INJ"
-  "INFINITE_DIFF_FINITE" > "Infinite_Set.Diff_infinite_finite"
-  "IND_SUC_def" > "HOLLight.hollight.IND_SUC_def"
-  "IND_SUC_0_EXISTS" > "HOLLight.hollight.IND_SUC_0_EXISTS"
-  "IND_0_def" > "HOLLight.hollight.IND_0_def"
-  "IMP_EQ_CLAUSE" > "HOLLight.hollight.IMP_EQ_CLAUSE"
-  "IMP_CONJ_ALT" > "HOLLight.hollight.IMP_CONJ_ALT"
-  "IMP_CONJ" > "HOL.imp_conjL"
-  "IMP_CLAUSES" > "HOLLight.hollight.IMP_CLAUSES"
-  "IMAGE_o" > "Fun.image_compose"
-  "IMAGE_UNIONS" > "HOLLight.hollight.IMAGE_UNIONS"
-  "IMAGE_UNION" > "Set.image_Un"
-  "IMAGE_SUBSET" > "Set.image_mono"
-  "IMAGE_INTER_INJ" > "HOLLight.hollight.IMAGE_INTER_INJ"
-  "IMAGE_INJECTIVE_IMAGE_OF_SUBSET" > "HOLLight.hollight.IMAGE_INJECTIVE_IMAGE_OF_SUBSET"
-  "IMAGE_IMP_INJECTIVE_GEN" > "HOLLight.hollight.IMAGE_IMP_INJECTIVE_GEN"
-  "IMAGE_IMP_INJECTIVE" > "HOLLight.hollight.IMAGE_IMP_INJECTIVE"
-  "IMAGE_ID" > "Set.image_ident"
-  "IMAGE_I" > "Fun.image_id"
-  "IMAGE_EQ_EMPTY" > "Set.image_is_empty"
-  "IMAGE_DIFF_INJ" > "HOLLight.hollight.IMAGE_DIFF_INJ"
-  "IMAGE_DELETE_INJ" > "HOLLight.hollight.IMAGE_DELETE_INJ"
-  "IMAGE_CONST" > "Set.image_constant_conv"
-  "IMAGE_CLAUSES" > "HOLLight.hollight.IMAGE_CLAUSES"
-  "HREAL_MUL_RZERO" > "HOLLight.hollight.HREAL_MUL_RZERO"
-  "HREAL_MUL_LZERO" > "HOLLight.hollight.HREAL_MUL_LZERO"
-  "HREAL_LE_MUL_RCANCEL_IMP" > "HOLLight.hollight.HREAL_LE_MUL_RCANCEL_IMP"
-  "HREAL_LE_EXISTS_DEF" > "HOLLight.hollight.HREAL_LE_EXISTS_DEF"
-  "HREAL_LE_ADD_RCANCEL" > "HOLLight.hollight.HREAL_LE_ADD_RCANCEL"
-  "HREAL_LE_ADD_LCANCEL" > "HOLLight.hollight.HREAL_LE_ADD_LCANCEL"
-  "HREAL_LE_ADD2" > "HOLLight.hollight.HREAL_LE_ADD2"
-  "HREAL_EQ_ADD_RCANCEL" > "HOLLight.hollight.HREAL_EQ_ADD_RCANCEL"
-  "HREAL_EQ_ADD_LCANCEL" > "HOLLight.hollight.HREAL_EQ_ADD_LCANCEL"
-  "HREAL_ADD_RID" > "HOLLight.hollight.HREAL_ADD_RID"
-  "HREAL_ADD_RDISTRIB" > "HOLLight.hollight.HREAL_ADD_RDISTRIB"
-  "HREAL_ADD_AC" > "HOLLight.hollight.HREAL_ADD_AC"
-  "HD_APPEND" > "List.hd_append"
-  "HAS_SIZE_def" > "HOLLight.hollight.HAS_SIZE_def"
-  "HAS_SIZE_UNIONS" > "HOLLight.hollight.HAS_SIZE_UNIONS"
-  "HAS_SIZE_UNION" > "HOLLight.hollight.HAS_SIZE_UNION"
-  "HAS_SIZE_SUC" > "HOLLight.hollight.HAS_SIZE_SUC"
-  "HAS_SIZE_PRODUCT_DEPENDENT" > "HOLLight.hollight.HAS_SIZE_PRODUCT_DEPENDENT"
-  "HAS_SIZE_PRODUCT" > "HOLLight.hollight.HAS_SIZE_PRODUCT"
-  "HAS_SIZE_POWERSET" > "HOLLight.hollight.HAS_SIZE_POWERSET"
-  "HAS_SIZE_NUMSEG_LT" > "HOLLight.hollight.HAS_SIZE_NUMSEG_LT"
-  "HAS_SIZE_NUMSEG_LE" > "HOLLight.hollight.HAS_SIZE_NUMSEG_LE"
-  "HAS_SIZE_NUMSEG_1" > "HOLLight.hollight.HAS_SIZE_NUMSEG_1"
-  "HAS_SIZE_NUMSEG" > "HOLLight.hollight.HAS_SIZE_NUMSEG"
-  "HAS_SIZE_INDEX" > "HOLLight.hollight.HAS_SIZE_INDEX"
-  "HAS_SIZE_IMAGE_INJ_EQ" > "HOLLight.hollight.HAS_SIZE_IMAGE_INJ_EQ"
-  "HAS_SIZE_IMAGE_INJ" > "HOLLight.hollight.HAS_SIZE_IMAGE_INJ"
-  "HAS_SIZE_FUNSPACE" > "HOLLight.hollight.HAS_SIZE_FUNSPACE"
-  "HAS_SIZE_FINITE_IMAGE" > "HOLLight.hollight.HAS_SIZE_FINITE_IMAGE"
-  "HAS_SIZE_DIFF" > "HOLLight.hollight.HAS_SIZE_DIFF"
-  "HAS_SIZE_CROSS" > "HOLLight.hollight.HAS_SIZE_CROSS"
-  "HAS_SIZE_CLAUSES" > "HOLLight.hollight.HAS_SIZE_CLAUSES"
-  "HAS_SIZE_CARD" > "HOLLight.hollight.HAS_SIZE_CARD"
-  "HAS_SIZE_1" > "HOLLight.hollight.HAS_SIZE_1"
-  "HAS_SIZE_0" > "HOLLight.hollight.HAS_SIZE_0"
-  "GE_C" > "HOLLight.hollight.GE_C"
-  "FUN_IN_IMAGE" > "Set.imageI"
-  "FUN_EQ_THM" > "HOL.fun_eq_iff"
-  "FUNCTION_FACTORS_RIGHT" > "HOLLight.hollight.FUNCTION_FACTORS_RIGHT"
-  "FUNCTION_FACTORS_LEFT" > "HOLLight.hollight.FUNCTION_FACTORS_LEFT"
-  "FST" > "Product_Type.fst_conv"
-  "FORALL_UNWIND_THM2" > "HOL.simp_thms_41"
-  "FORALL_UNWIND_THM1" > "HOL.simp_thms_42"
-  "FORALL_UNCURRY" > "HOLLight.hollight.FORALL_UNCURRY"
-  "FORALL_TRIPLED_THM" > "HOLLight.hollight.FORALL_TRIPLED_THM"
-  "FORALL_SUBSET_IMAGE" > "HOLLight.hollight.FORALL_SUBSET_IMAGE"
-  "FORALL_SIMP" > "HOL.simp_thms_35"
-  "FORALL_PAIR_THM" > "Product_Type.split_paired_All"
-  "FORALL_PAIRED_THM" > "HOLLight.hollight.FORALL_PAIRED_THM"
-  "FORALL_NOT_THM" > "HOL.not_ex"
-  "FORALL_IN_UNIONS" > "HOLLight.hollight.FORALL_IN_UNIONS"
-  "FORALL_IN_INSERT" > "HOLLight.hollight.FORALL_IN_INSERT"
-  "FORALL_IN_IMAGE" > "HOLLight.hollight.FORALL_IN_IMAGE"
-  "FORALL_IN_GSPEC" > "HOLLight.hollight.FORALL_IN_GSPEC"
-  "FORALL_IN_CLAUSES" > "HOLLight.hollight.FORALL_IN_CLAUSES"
-  "FORALL_FINITE_INDEX" > "HOLLight.hollight.FORALL_FINITE_INDEX"
-  "FORALL_BOOL_THM" > "Set.all_bool_eq"
-  "FORALL_AND_THM" > "HOL.all_conj_distrib"
-  "FORALL_ALL" > "HOLLightList.FORALL_ALL"
-  "FNIL_def" > "HOLLight.hollight.FNIL_def"
-  "FINREC_def" > "HOLLight.hollight.FINREC_def"
-  "FINREC_UNIQUE_LEMMA" > "HOLLight.hollight.FINREC_UNIQUE_LEMMA"
-  "FINREC_SUC_LEMMA" > "HOLLight.hollight.FINREC_SUC_LEMMA"
-  "FINREC_FUN_LEMMA" > "HOLLight.hollight.FINREC_FUN_LEMMA"
-  "FINREC_FUN" > "HOLLight.hollight.FINREC_FUN"
-  "FINREC_EXISTS_LEMMA" > "HOLLight.hollight.FINREC_EXISTS_LEMMA"
-  "FINREC_1_LEMMA" > "HOLLight.hollight.FINREC_1_LEMMA"
-  "FINITE_UNION_IMP" > "Finite_Set.finite_UnI"
-  "FINITE_UNIONS" > "HOLLight.hollight.FINITE_UNIONS"
-  "FINITE_UNION" > "Finite_Set.finite_Un"
-  "FINITE_SUPPORT_DELTA" > "HOLLight.hollight.FINITE_SUPPORT_DELTA"
-  "FINITE_SUPPORT" > "HOLLight.hollight.FINITE_SUPPORT"
-  "FINITE_SUM_IMAGE" > "HOLLight.hollight.FINITE_SUM_IMAGE"
-  "FINITE_SUBSET_IMAGE_IMP" > "HOLLight.hollight.FINITE_SUBSET_IMAGE_IMP"
-  "FINITE_SUBSET_IMAGE" > "HOLLight.hollight.FINITE_SUBSET_IMAGE"
-  "FINITE_SUBSET" > "Finite_Set.finite_subset"
-  "FINITE_SING" > "HOLLight.hollight.FINITE_SING"
-  "FINITE_RESTRICT" > "HOLLight.hollight.FINITE_RESTRICT"
-  "FINITE_RECURSION_DELETE" > "HOLLight.hollight.FINITE_RECURSION_DELETE"
-  "FINITE_RECURSION" > "HOLLight.hollight.FINITE_RECURSION"
-  "FINITE_REAL_INTERVAL" > "HOLLight.hollight.FINITE_REAL_INTERVAL"
-  "FINITE_PRODUCT_DEPENDENT" > "HOLLight.hollight.FINITE_PRODUCT_DEPENDENT"
-  "FINITE_PRODUCT" > "HOLLight.hollight.FINITE_PRODUCT"
-  "FINITE_POWERSET" > "HOLLight.hollight.FINITE_POWERSET"
-  "FINITE_NUMSEG_LT" > "HOLLight.hollight.FINITE_NUMSEG_LT"
-  "FINITE_NUMSEG_LE" > "HOLLight.hollight.FINITE_NUMSEG_LE"
-  "FINITE_NUMSEG" > "SetInterval.finite_atLeastAtMost"
-  "FINITE_INTSEG" > "HOLLight.hollight.FINITE_INTSEG"
-  "FINITE_INTER" > "Finite_Set.finite_Int"
-  "FINITE_INSERT" > "Finite_Set.finite_insert"
-  "FINITE_INDUCT_STRONG" > "Finite_Set.finite_induct"
-  "FINITE_INDUCT_DELETE" > "HOLLight.hollight.FINITE_INDUCT_DELETE"
-  "FINITE_INDEX_WORKS" > "HOLLight.hollight.FINITE_INDEX_WORKS"
-  "FINITE_INDEX_NUMSEG" > "HOLLight.hollight.FINITE_INDEX_NUMSEG"
-  "FINITE_INDEX_NUMBERS" > "HOLLight.hollight.FINITE_INDEX_NUMBERS"
-  "FINITE_INDEX_INRANGE" > "HOLLight.hollight.FINITE_INDEX_INRANGE"
-  "FINITE_INDEX_INJ" > "HOLLight.hollight.FINITE_INDEX_INJ"
-  "FINITE_IMAGE_INJ_GENERAL" > "HOLLight.hollight.FINITE_IMAGE_INJ_GENERAL"
-  "FINITE_IMAGE_INJ_EQ" > "HOLLight.hollight.FINITE_IMAGE_INJ_EQ"
-  "FINITE_IMAGE_INJ" > "HOLLight.hollight.FINITE_IMAGE_INJ"
-  "FINITE_IMAGE_IMAGE" > "HOLLight.hollight.FINITE_IMAGE_IMAGE"
-  "FINITE_IMAGE_EXPAND" > "HOLLight.hollight.FINITE_IMAGE_EXPAND"
-  "FINITE_IMAGE" > "Finite_Set.finite_imageI"
-  "FINITE_HAS_SIZE" > "HOLLight.hollight.FINITE_HAS_SIZE"
-  "FINITE_FUNSPACE" > "HOLLight.hollight.FINITE_FUNSPACE"
-  "FINITE_FINITE_UNIONS" > "HOLLight.hollight.FINITE_FINITE_UNIONS"
-  "FINITE_FINITE_PREIMAGE_GENERAL" > "HOLLight.hollight.FINITE_FINITE_PREIMAGE_GENERAL"
-  "FINITE_FINITE_PREIMAGE" > "HOLLight.hollight.FINITE_FINITE_PREIMAGE"
-  "FINITE_FINITE_IMAGE" > "HOLLight.hollight.FINITE_FINITE_IMAGE"
-  "FINITE_EMPTY" > "Finite_Set.finite.emptyI"
-  "FINITE_DIFF" > "Finite_Set.finite_Diff"
-  "FINITE_DELETE_IMP" > "HOLLight.hollight.FINITE_DELETE_IMP"
-  "FINITE_DELETE" > "HOLLight.hollight.FINITE_DELETE"
-  "FINITE_CROSS" > "HOLLight.hollight.FINITE_CROSS"
-  "FINITE_CART" > "HOLLight.hollight.FINITE_CART"
-  "FILTER_MAP" > "List.filter_map"
-  "FILTER_APPEND" > "List.filter_append"
-  "FCONS_def" > "HOLLight.hollight.FCONS_def"
-  "FCONS_UNDO" > "HOLLight.hollight.FCONS_UNDO"
-  "FACT_NZ" > "Fact.fact_nonzero_nat"
-  "FACT_MONO" > "Fact.fact_mono_nat"
-  "FACT_LT" > "Fact.fact_gt_zero_nat"
-  "FACT_LE" > "Fact.fact_ge_one_nat"
-  "EX_MEM" > "HOLLightList.EX_MEM"
-  "EX_IMP" > "HOLLightList.EX_IMP"
-  "EXTENSION" > "Set.set_eq_iff"
-  "EXP_ZERO" > "Power.power_0_left"
-  "EXP_ONE" > "Power.monoid_mult_class.power_one"
-  "EXP_MULT" > "Power.monoid_mult_class.power_mult"
-  "EXP_MONO_LT_IMP" > "HOLLight.hollight.EXP_MONO_LT_IMP"
-  "EXP_MONO_LT" > "HOLLight.hollight.EXP_MONO_LT"
-  "EXP_MONO_LE_IMP" > "HOLLight.hollight.EXP_MONO_LE_IMP"
-  "EXP_MONO_LE" > "HOLLight.hollight.EXP_MONO_LE"
-  "EXP_MONO_EQ" > "HOLLight.hollight.EXP_MONO_EQ"
-  "EXP_LT_0" > "HOLLight.hollight.EXP_LT_0"
-  "EXP_EQ_1" > "HOLLight.hollight.EXP_EQ_1"
-  "EXP_EQ_0" > "Power.power_eq_0_iff"
-  "EXP_ADD" > "Power.monoid_mult_class.power_add"
-  "EXP_2" > "Nat_Numeral.monoid_mult_class.power2_eq_square"
-  "EXP_1" > "Power.monoid_mult_class.power_one_right"
-  "EXISTS_UNIQUE_THM" > "HOLLightCompat.EXISTS_UNIQUE_THM"
-  "EXISTS_UNIQUE_REFL" > "HOL.ex1_eq_1"
-  "EXISTS_UNIQUE_ALT" > "HOLLight.hollight.EXISTS_UNIQUE_ALT"
-  "EXISTS_UNIQUE" > "HOL.Ex1_def"
-  "EXISTS_UNCURRY" > "HOLLight.hollight.EXISTS_UNCURRY"
-  "EXISTS_TRIPLED_THM" > "HOLLight.hollight.EXISTS_TRIPLED_THM"
-  "EXISTS_THM" > "HOL4Setup.EXISTS_DEF"
-  "EXISTS_SUBSET_IMAGE" > "HOLLight.hollight.EXISTS_SUBSET_IMAGE"
-  "EXISTS_SIMP" > "HOL.simp_thms_36"
-  "EXISTS_REFL" > "HOL.simp_thms_37"
-  "EXISTS_PAIR_THM" > "Product_Type.split_paired_Ex"
-  "EXISTS_PAIRED_THM" > "HOLLight.hollight.EXISTS_PAIRED_THM"
-  "EXISTS_OR_THM" > "HOL.ex_disj_distrib"
-  "EXISTS_ONE_REP" > "HOLLight.hollight.EXISTS_ONE_REP"
-  "EXISTS_NOT_THM" > "HOL.not_all"
-  "EXISTS_IN_UNIONS" > "HOLLight.hollight.EXISTS_IN_UNIONS"
-  "EXISTS_IN_INSERT" > "HOLLight.hollight.EXISTS_IN_INSERT"
-  "EXISTS_IN_IMAGE" > "HOLLight.hollight.EXISTS_IN_IMAGE"
-  "EXISTS_IN_GSPEC" > "HOLLight.hollight.EXISTS_IN_GSPEC"
-  "EXISTS_IN_CLAUSES" > "HOLLight.hollight.EXISTS_IN_CLAUSES"
-  "EXISTS_FINITE_SUBSET_IMAGE" > "HOLLight.hollight.EXISTS_FINITE_SUBSET_IMAGE"
-  "EXISTS_EX" > "HOLLightList.EXISTS_EX"
-  "EXISTS_BOOL_THM" > "Set.ex_bool_eq"
-  "EXCLUDED_MIDDLE" > "HOLLight.hollight.EXCLUDED_MIDDLE"
-  "EVEN_SUB" > "HOLLight.hollight.EVEN_SUB"
-  "EVEN_OR_ODD" > "HOLLight.hollight.EVEN_OR_ODD"
-  "EVEN_ODD_DECOMPOSITION" > "HOLLight.hollight.EVEN_ODD_DECOMPOSITION"
-  "EVEN_MULT" > "Parity.even_product_nat"
-  "EVEN_MOD" > "HOLLight.hollight.EVEN_MOD"
-  "EVEN_EXP" > "HOLLight.hollight.EVEN_EXP"
-  "EVEN_EXISTS_LEMMA" > "HOLLight.hollight.EVEN_EXISTS_LEMMA"
-  "EVEN_EXISTS" > "Parity.even_mult_two_ex"
-  "EVEN_DOUBLE" > "HOLLight.hollight.EVEN_DOUBLE"
-  "EVEN_AND_ODD" > "HOLLight.hollight.EVEN_AND_ODD"
-  "EVEN_ADD" > "Parity.even_add"
-  "EQ_UNIV" > "HOLLight.hollight.EQ_UNIV"
-  "EQ_TRANS" > "HOL.trans"
-  "EQ_SYM_EQ" > "HOL.eq_ac_1"
-  "EQ_SYM" > "HOL.eq_reflection"
-  "EQ_REFL" > "HOL.refl"
-  "EQ_MULT_RCANCEL" > "Nat.mult_cancel2"
-  "EQ_MULT_LCANCEL" > "Numeral_Simprocs.nat_mult_eq_cancel_disj"
-  "EQ_IMP_LE" > "Nat.eq_imp_le"
-  "EQ_EXT" > "HOL.eq_reflection"
-  "EQ_EXP" > "HOLLight.hollight.EQ_EXP"
-  "EQ_CLAUSES" > "HOLLight.hollight.EQ_CLAUSES"
-  "EQ_ADD_RCANCEL_0" > "HOLLight.hollight.EQ_ADD_RCANCEL_0"
-  "EQ_ADD_RCANCEL" > "Groups.cancel_semigroup_add_class.add_right_cancel"
-  "EQ_ADD_LCANCEL_0" > "HOLLight.hollight.EQ_ADD_LCANCEL_0"
-  "EQ_ADD_LCANCEL" > "Groups.cancel_semigroup_add_class.add_left_cancel"
-  "EMPTY_UNIONS" > "HOLLight.hollight.EMPTY_UNIONS"
-  "EMPTY_UNION" > "Lattices.bounded_lattice_bot_class.sup_eq_bot_iff"
-  "EMPTY_SUBSET" > "Orderings.bot_class.bot_least"
-  "EMPTY_NOT_UNIV" > "HOLLight.hollight.EMPTY_NOT_UNIV"
-  "EMPTY_GSPEC" > "HOLLight.hollight.EMPTY_GSPEC"
-  "EMPTY_DIFF" > "Set.empty_Diff"
-  "EMPTY_DELETE" > "HOLLight.hollight.EMPTY_DELETE"
-  "EL_CONS" > "List.nth_Cons'"
-  "EL_APPEND" > "List.nth_append"
-  "DIV_UNIQ" > "HOLLight.hollight.DIV_UNIQ"
-  "DIV_REFL" > "Divides.semiring_div_class.div_self"
-  "DIV_MUL_LE" > "HOLLight.hollight.DIV_MUL_LE"
-  "DIV_MULT2" > "HOLLight.hollight.DIV_MULT2"
-  "DIV_MONO_LT" > "HOLLight.hollight.DIV_MONO_LT"
-  "DIV_MONO2" > "HOLLight.hollight.DIV_MONO2"
-  "DIV_MONO" > "HOLLight.hollight.DIV_MONO"
-  "DIV_MOD" > "HOLLight.hollight.DIV_MOD"
-  "DIV_LT" > "Divides.div_less"
-  "DIV_LE_EXCLUSION" > "HOLLight.hollight.DIV_LE_EXCLUSION"
-  "DIV_LE" > "HOLLight.hollight.DIV_LE"
-  "DIV_EQ_EXCLUSION" > "HOLLight.hollight.DIV_EQ_EXCLUSION"
-  "DIV_EQ_0" > "HOLLight.hollight.DIV_EQ_0"
-  "DIV_DIV" > "HOLLight.hollight.DIV_DIV"
-  "DIV_ADD_MOD" > "HOLLight.hollight.DIV_ADD_MOD"
-  "DIVMOD_UNIQ_LEMMA" > "HOLLight.hollight.DIVMOD_UNIQ_LEMMA"
-  "DIVMOD_UNIQ" > "HOLLight.hollight.DIVMOD_UNIQ"
-  "DIVMOD_EXIST_0" > "HOLLight.hollight.DIVMOD_EXIST_0"
-  "DIVMOD_EXIST" > "HOLLight.hollight.DIVMOD_EXIST"
-  "DIVMOD_ELIM_THM" > "HOLLight.hollight.DIVMOD_ELIM_THM"
-  "DIVISION" > "HOLLight.hollight.DIVISION"
-  "DIST_TRIANGLE_LE" > "HOLLight.hollight.DIST_TRIANGLE_LE"
-  "DIST_TRIANGLES_LE" > "HOLLight.hollight.DIST_TRIANGLES_LE"
-  "DIST_SYM" > "HOLLight.hollight.DIST_SYM"
-  "DIST_RZERO" > "HOLLight.hollight.DIST_RZERO"
-  "DIST_RMUL" > "HOLLight.hollight.DIST_RMUL"
-  "DIST_REFL" > "HOLLight.hollight.DIST_REFL"
-  "DIST_RADD_0" > "HOLLight.hollight.DIST_RADD_0"
-  "DIST_RADD" > "HOLLight.hollight.DIST_RADD"
-  "DIST_LZERO" > "HOLLight.hollight.DIST_LZERO"
-  "DIST_LMUL" > "HOLLight.hollight.DIST_LMUL"
-  "DIST_LE_CASES" > "HOLLight.hollight.DIST_LE_CASES"
-  "DIST_LADD_0" > "HOLLight.hollight.DIST_LADD_0"
-  "DIST_LADD" > "HOLLight.hollight.DIST_LADD"
-  "DIST_EQ_0" > "HOLLight.hollight.DIST_EQ_0"
-  "DIST_ELIM_THM" > "HOLLight.hollight.DIST_ELIM_THM"
-  "DISJ_SYM" > "Groebner_Basis.dnf_4"
-  "DISJ_ASSOC" > "HOL.disj_ac_3"
-  "DISJ_ACI" > "HOLLight.hollight.DISJ_ACI"
-  "DISJOINT_UNION" > "HOLLight.hollight.DISJOINT_UNION"
-  "DISJOINT_SYM" > "HOLLight.hollight.DISJOINT_SYM"
-  "DISJOINT_NUMSEG" > "HOLLight.hollight.DISJOINT_NUMSEG"
-  "DISJOINT_INSERT" > "HOLLight.hollight.DISJOINT_INSERT"
-  "DISJOINT_EMPTY_REFL" > "HOLLight.hollight.DISJOINT_EMPTY_REFL"
-  "DISJOINT_EMPTY" > "HOLLight.hollight.DISJOINT_EMPTY"
-  "DISJOINT_DELETE_SYM" > "HOLLight.hollight.DISJOINT_DELETE_SYM"
-  "DIMINDEX_UNIV" > "HOLLight.hollight.DIMINDEX_UNIV"
-  "DIMINDEX_UNIQUE" > "HOLLight.hollight.DIMINDEX_UNIQUE"
-  "DIMINDEX_NONZERO" > "HOLLight.hollight.DIMINDEX_NONZERO"
-  "DIMINDEX_GE_1" > "HOLLight.hollight.DIMINDEX_GE_1"
-  "DIMINDEX_FINITE_IMAGE" > "HOLLight.hollight.DIMINDEX_FINITE_IMAGE"
-  "DIFF_UNIV" > "Set.Diff_UNIV"
-  "DIFF_INTERS" > "HOLLight.hollight.DIFF_INTERS"
-  "DIFF_INSERT" > "Set.Diff_insert2"
-  "DIFF_EQ_EMPTY" > "Set.Diff_cancel"
-  "DIFF_EMPTY" > "Set.Diff_empty"
-  "DIFF_DIFF" > "Set.Diff_idemp"
-  "DEST_REC_INJ" > "HOLLight.hollight.recspace._dest_rec_inject"
-  "DELETE_SUBSET" > "HOLLight.hollight.DELETE_SUBSET"
-  "DELETE_NON_ELEMENT" > "HOLLight.hollight.DELETE_NON_ELEMENT"
-  "DELETE_INTER" > "HOLLight.hollight.DELETE_INTER"
-  "DELETE_INSERT" > "HOLLight.hollight.DELETE_INSERT"
-  "DELETE_DELETE" > "HOLLight.hollight.DELETE_DELETE"
-  "DELETE_COMM" > "HOLLight.hollight.DELETE_COMM"
-  "DEF_~" > "Groebner_Basis.bool_simps_19"
-  "DEF_vector" > "HOLLight.hollight.DEF_vector"
-  "DEF_treal_of_num" > "HOLLight.hollight.DEF_treal_of_num"
-  "DEF_treal_neg" > "HOLLight.hollight.DEF_treal_neg"
-  "DEF_treal_mul" > "HOLLight.hollight.DEF_treal_mul"
-  "DEF_treal_le" > "HOLLight.hollight.DEF_treal_le"
-  "DEF_treal_inv" > "HOLLight.hollight.DEF_treal_inv"
-  "DEF_treal_eq" > "HOLLight.hollight.DEF_treal_eq"
-  "DEF_treal_add" > "HOLLight.hollight.DEF_treal_add"
-  "DEF_tailadmissible" > "HOLLight.hollight.DEF_tailadmissible"
-  "DEF_support" > "HOLLight.hollight.DEF_support"
-  "DEF_superadmissible" > "HOLLight.hollight.DEF_superadmissible"
-  "DEF_sum" > "HOLLight.hollight.DEF_sum"
-  "DEF_sndcart" > "HOLLight.hollight.DEF_sndcart"
-  "DEF_set_of_list" > "HOLLightList.DEF_set_of_list"
-  "DEF_rem" > "HOLLight.hollight.DEF_rem"
-  "DEF_real_sub" > "HOLLight.hollight.DEF_real_sub"
-  "DEF_real_sgn" > "HOLLight.hollight.DEF_real_sgn"
-  "DEF_real_pow" > "HOLLight.hollight.DEF_real_pow"
-  "DEF_real_of_num" > "HOLLight.hollight.DEF_real_of_num"
-  "DEF_real_neg" > "HOLLight.hollight.DEF_real_neg"
-  "DEF_real_mul" > "HOLLight.hollight.DEF_real_mul"
-  "DEF_real_mod" > "HOLLight.hollight.DEF_real_mod"
-  "DEF_real_min" > "HOLLight.hollight.DEF_real_min"
-  "DEF_real_max" > "HOLLight.hollight.DEF_real_max"
-  "DEF_real_lt" > "HOLLight.hollight.DEF_real_lt"
-  "DEF_real_le" > "HOLLight.hollight.DEF_real_le"
-  "DEF_real_inv" > "HOLLight.hollight.DEF_real_inv"
-  "DEF_real_gt" > "HOLLight.hollight.DEF_real_gt"
-  "DEF_real_ge" > "HOLLight.hollight.DEF_real_ge"
-  "DEF_real_div" > "HOLLight.hollight.DEF_real_div"
-  "DEF_real_add" > "HOLLight.hollight.DEF_real_add"
-  "DEF_real_abs" > "HOLLight.hollight.DEF_real_abs"
-  "DEF_pastecart" > "HOLLight.hollight.DEF_pastecart"
-  "DEF_pairwise" > "HOLLight.hollight.DEF_pairwise"
-  "DEF_o" > "Fun.comp_def"
-  "DEF_num_of_int" > "HOLLight.hollight.DEF_num_of_int"
-  "DEF_num_mod" > "HOLLight.hollight.DEF_num_mod"
-  "DEF_num_gcd" > "HOLLight.hollight.DEF_num_gcd"
-  "DEF_num_divides" > "HOLLight.hollight.DEF_num_divides"
-  "DEF_num_coprime" > "HOLLight.hollight.DEF_num_coprime"
-  "DEF_nsum" > "HOLLight.hollight.DEF_nsum"
-  "DEF_neutral" > "HOLLight.hollight.DEF_neutral"
-  "DEF_nadd_rinv" > "HOLLight.hollight.DEF_nadd_rinv"
-  "DEF_nadd_of_num" > "HOLLight.hollight.DEF_nadd_of_num"
-  "DEF_nadd_mul" > "HOLLight.hollight.DEF_nadd_mul"
-  "DEF_nadd_le" > "HOLLight.hollight.DEF_nadd_le"
-  "DEF_nadd_inv" > "HOLLight.hollight.DEF_nadd_inv"
-  "DEF_nadd_eq" > "HOLLight.hollight.DEF_nadd_eq"
-  "DEF_nadd_add" > "HOLLight.hollight.DEF_nadd_add"
-  "DEF_monoidal" > "HOLLight.hollight.DEF_monoidal"
-  "DEF_minimal" > "HOLLight.hollight.DEF_minimal"
-  "DEF_lambda" > "HOLLight.hollight.DEF_lambda"
-  "DEF_iterate" > "HOLLight.hollight.DEF_iterate"
-  "DEF_is_nadd" > "HOLLight.hollight.DEF_is_nadd"
-  "DEF_integer" > "HOLLight.hollight.DEF_integer"
-  "DEF_int_sub" > "HOLLight.hollight.DEF_int_sub"
-  "DEF_int_sgn" > "HOLLight.hollight.DEF_int_sgn"
-  "DEF_int_pow" > "HOLLight.hollight.DEF_int_pow"
-  "DEF_int_of_num" > "HOLLight.hollight.DEF_int_of_num"
-  "DEF_int_neg" > "HOLLight.hollight.DEF_int_neg"
-  "DEF_int_mul" > "HOLLight.hollight.DEF_int_mul"
-  "DEF_int_mod" > "HOLLight.hollight.DEF_int_mod"
-  "DEF_int_min" > "HOLLight.hollight.DEF_int_min"
-  "DEF_int_max" > "HOLLight.hollight.DEF_int_max"
-  "DEF_int_lt" > "HOLLight.hollight.DEF_int_lt"
-  "DEF_int_le" > "HOLLight.hollight.DEF_int_le"
-  "DEF_int_gt" > "HOLLight.hollight.DEF_int_gt"
-  "DEF_int_ge" > "HOLLight.hollight.DEF_int_ge"
-  "DEF_int_gcd" > "HOLLight.hollight.DEF_int_gcd"
-  "DEF_int_divides" > "HOLLight.hollight.DEF_int_divides"
-  "DEF_int_coprime" > "HOLLight.hollight.DEF_int_coprime"
-  "DEF_int_add" > "HOLLight.hollight.DEF_int_add"
-  "DEF_int_abs" > "HOLLight.hollight.DEF_int_abs"
-  "DEF_hreal_of_num" > "HOLLight.hollight.DEF_hreal_of_num"
-  "DEF_hreal_mul" > "HOLLight.hollight.DEF_hreal_mul"
-  "DEF_hreal_le" > "HOLLight.hollight.DEF_hreal_le"
-  "DEF_hreal_inv" > "HOLLight.hollight.DEF_hreal_inv"
-  "DEF_hreal_add" > "HOLLight.hollight.DEF_hreal_add"
-  "DEF_fstcart" > "HOLLight.hollight.DEF_fstcart"
-  "DEF_div" > "HOLLight.hollight.DEF_div"
-  "DEF_dist" > "HOLLight.hollight.DEF_dist"
-  "DEF_dimindex" > "HOLLight.hollight.DEF_dimindex"
-  "DEF_admissible" > "HOLLight.hollight.DEF_admissible"
-  "DEF__star_" > "HOLLightCompat.DEF__star_"
-  "DEF__slash__backslash_" > "HOLLightCompat.DEF__slash__backslash_"
-  "DEF__questionmark__exclamationmark_" > "HOLLightCompat.EXISTS_UNIQUE_THM"
-  "DEF__questionmark_" > "HOL.Ex_def"
-  "DEF__lessthan__equal__c" > "HOLLight.hollight.DEF__lessthan__equal__c"
-  "DEF__lessthan__equal_" > "HOLLightCompat.DEF__lessthan__equal_"
-  "DEF__lessthan__c" > "HOLLight.hollight.DEF__lessthan__c"
-  "DEF__lessthan_" > "HOLLightCompat.DEF__lessthan_"
-  "DEF__greaterthan__equal__c" > "HOLLight.hollight.DEF__greaterthan__equal__c"
-  "DEF__greaterthan__equal_" > "HOLLightCompat.DEF__greaterthan__equal_"
-  "DEF__greaterthan__c" > "HOLLight.hollight.DEF__greaterthan__c"
-  "DEF__greaterthan_" > "HOLLightCompat.DEF__greaterthan_"
-  "DEF__exclamationmark_" > "HOL.All_def"
-  "DEF__equal__equal__greaterthan_" > "HOLLightCompat.DEF__equal__equal__greaterthan_"
-  "DEF__equal__equal_" > "HOLLight.hollight.DEF__equal__equal_"
-  "DEF__equal__c" > "HOLLight.hollight.DEF__equal__c"
-  "DEF__dot__dot_" > "HOLLightCompat.dotdot_def"
-  "DEF__backslash__slash_" > "HOL.or_def"
-  "DEF__UNGUARDED_PATTERN" > "HOLLight.hollight.DEF__UNGUARDED_PATTERN"
-  "DEF__SEQPATTERN" > "HOLLight.hollight.DEF__SEQPATTERN"
-  "DEF__MATCH" > "HOLLight.hollight.DEF__MATCH"
-  "DEF__GUARDED_PATTERN" > "HOLLight.hollight.DEF__GUARDED_PATTERN"
-  "DEF__FUNCTION" > "HOLLight.hollight.DEF__FUNCTION"
-  "DEF__FALSITY_" > "HOLLight.hollight.DEF__FALSITY_"
-  "DEF__11937" > "HOLLight.hollight.DEF__11937"
-  "DEF_ZRECSPACE" > "HOLLight.hollight.DEF_ZRECSPACE"
-  "DEF_ZCONSTR" > "HOLLight.hollight.DEF_ZCONSTR"
-  "DEF_ZBOT" > "HOLLight.hollight.DEF_ZBOT"
-  "DEF_WF" > "HOLLightCompat.DEF_WF"
-  "DEF_UNIV" > "HOLLightCompat.DEF_UNIV"
-  "DEF_UNIONS" > "HOLLightCompat.DEF_UNIONS"
-  "DEF_UNION" > "HOLLightCompat.DEF_UNION"
-  "DEF_UNCURRY" > "HOLLight.hollight.DEF_UNCURRY"
-  "DEF_T" > "HOL.True_def"
-  "DEF_SURJ" > "HOLLight.hollight.DEF_SURJ"
-  "DEF_SUBSET" > "HOLLightCompat.DEF_SUBSET"
-  "DEF_SND" > "HOLLightCompat.DEF_SND"
-  "DEF_SING" > "HOLLight.hollight.DEF_SING"
-  "DEF_SETSPEC" > "HOLLightCompat.SETSPEC_def"
-  "DEF_REVERSE" > "HOLLightList.DEF_REVERSE"
-  "DEF_REST" > "HOLLight.hollight.DEF_REST"
-  "DEF_REPLICATE" > "HOLLightList.DEF_REPLICATE"
-  "DEF_PSUBSET" > "HOLLightCompat.DEF_PSUBSET"
-  "DEF_PRE" > "HOLLightCompat.DEF_PRE"
-  "DEF_PASSOC" > "HOLLight.hollight.DEF_PASSOC"
-  "DEF_PAIRWISE" > "HOLLight.hollight.DEF_PAIRWISE"
-  "DEF_ONTO" > "Fun.surj_def"
-  "DEF_ONE_ONE" > "HOLLightCompat.DEF_ONE_ONE"
-  "DEF_ODD" > "HOLLightCompat.DEF_ODD"
-  "DEF_NUM_REP" > "HOLLight.hollight.DEF_NUM_REP"
-  "DEF_NUMSUM" > "HOLLight.hollight.DEF_NUMSUM"
-  "DEF_NUMSND" > "HOLLight.hollight.DEF_NUMSND"
-  "DEF_NUMRIGHT" > "HOLLight.hollight.DEF_NUMRIGHT"
-  "DEF_NUMPAIR" > "HOLLight.hollight.DEF_NUMPAIR"
-  "DEF_NUMLEFT" > "HOLLight.hollight.DEF_NUMLEFT"
-  "DEF_NUMFST" > "HOLLight.hollight.DEF_NUMFST"
-  "DEF_NUMERAL" > "HOLLightCompat.NUMERAL_def"
-  "DEF_NULL" > "HOLLightList.DEF_NULL"
-  "DEF_MOD" > "HOLLightCompat.DEF_MOD"
-  "DEF_MIN" > "Orderings.ord_class.min_def"
-  "DEF_MEM" > "HOLLightList.DEF_MEM"
-  "DEF_MEASURE" > "HOLLightCompat.MEASURE_def"
-  "DEF_MAX" > "Orderings.ord_class.max_def"
-  "DEF_MAP" > "HOLLightList.DEF_MAP"
-  "DEF_LET_END" > "HOLLight.hollight.DEF_LET_END"
-  "DEF_LET" > "HOLLightCompat.LET_def"
-  "DEF_LENGTH" > "HOLLightList.DEF_LENGTH"
-  "DEF_LAST" > "HOLLightList.DEF_LAST"
-  "DEF_ITSET" > "HOLLight.hollight.DEF_ITSET"
-  "DEF_ITLIST" > "HOLLightList.DEF_ITLIST"
-  "DEF_ISO" > "HOLLight.hollight.DEF_ISO"
-  "DEF_INTERS" > "HOLLightCompat.DEF_INTERS"
-  "DEF_INTER" > "HOLLightCompat.DEF_INTER"
-  "DEF_INSERT" > "HOLLightCompat.DEF_INSERT"
-  "DEF_INJP" > "HOLLight.hollight.DEF_INJP"
-  "DEF_INJN" > "HOLLight.hollight.DEF_INJN"
-  "DEF_INJF" > "HOLLight.hollight.DEF_INJF"
-  "DEF_INJA" > "HOLLight.hollight.DEF_INJA"
-  "DEF_INJ" > "HOLLight.hollight.DEF_INJ"
-  "DEF_INFINITE" > "HOLLightCompat.DEF_INFINITE"
-  "DEF_IND_SUC" > "HOLLight.hollight.DEF_IND_SUC"
-  "DEF_IND_0" > "HOLLight.hollight.DEF_IND_0"
-  "DEF_IN" > "Set.mem_def"
-  "DEF_IMAGE" > "HOLLightCompat.DEF_IMAGE"
-  "DEF_I" > "Fun.id_apply"
-  "DEF_HAS_SIZE" > "HOLLight.hollight.DEF_HAS_SIZE"
-  "DEF_GSPEC" > "Set.Collect_def"
-  "DEF_GEQ" > "HOLLightCompat.DEF_GEQ"
-  "DEF_GABS" > "HOLLightCompat.DEF_GABS"
-  "DEF_FST" > "HOLLightCompat.DEF_FST"
-  "DEF_FNIL" > "HOLLight.hollight.DEF_FNIL"
-  "DEF_FINREC" > "HOLLight.hollight.DEF_FINREC"
-  "DEF_FINITE" > "HOLLightCompat.DEF_FINITE"
-  "DEF_FILTER" > "HOLLightList.DEF_FILTER"
-  "DEF_FCONS" > "HOLLight.hollight.DEF_FCONS"
-  "DEF_FACT" > "HOLLightCompat.DEF_FACT"
-  "DEF_F" > "HOL.False_def"
-  "DEF_EXP" > "HOLLightCompat.DEF_EXP"
-  "DEF_EX" > "HOLLightList.DEF_EX"
-  "DEF_EVEN" > "HOLLightCompat.DEF_EVEN"
-  "DEF_EMPTY" > "HOLLightCompat.DEF_EMPTY"
-  "DEF_EL" > "HOLLightList.DEF_EL"
-  "DEF_DIV" > "HOLLightCompat.DEF_DIV"
-  "DEF_DISJOINT" > "HOLLightCompat.DEF_DISJOINT"
-  "DEF_DIFF" > "HOLLightCompat.DEF_DIFF"
-  "DEF_DELETE" > "HOLLightCompat.DEF_DELETE"
-  "DEF_DECIMAL" > "HOLLight.hollight.DEF_DECIMAL"
-  "DEF_CURRY" > "Product_Type.curry_conv"
-  "DEF_CROSS" > "HOLLight.hollight.DEF_CROSS"
-  "DEF_COUNTABLE" > "HOLLight.hollight.DEF_COUNTABLE"
-  "DEF_CONSTR" > "HOLLight.hollight.DEF_CONSTR"
-  "DEF_COND" > "HOLLightCompat.COND_DEF"
-  "DEF_CHOICE" > "HOLLightCompat.DEF_CHOICE"
-  "DEF_CASEWISE" > "HOLLight.hollight.DEF_CASEWISE"
-  "DEF_CARD" > "HOLLight.hollight.DEF_CARD"
-  "DEF_BUTLAST" > "HOLLightList.DEF_BUTLAST"
-  "DEF_BOTTOM" > "HOLLight.hollight.DEF_BOTTOM"
-  "DEF_BIT1" > "HOLLightCompat.BIT1_DEF"
-  "DEF_BIT0" > "HOLLightCompat.BIT0_DEF"
-  "DEF_BIJ" > "HOLLight.hollight.DEF_BIJ"
-  "DEF_ASCII" > "HOLLight.hollight.DEF_ASCII"
-  "DEF_APPEND" > "HOLLightList.DEF_APPEND"
-  "DEF_ALL2" > "HOLLightList.DEF_ALL2"
-  "DEF_ALL" > "HOLLightList.DEF_ALL"
-  "DEF_-" > "HOLLightCompat.DEF_MINUS"
-  "DEF_+" > "HOLLightCompat.DEF_PLUS"
-  "DEF_$" > "HOLLight.hollight.DEF_$"
-  "DECOMPOSITION" > "HOLLight.hollight.DECOMPOSITION"
-  "DECIMAL_def" > "HOLLight.hollight.DECIMAL_def"
-  "CROSS_def" > "HOLLight.hollight.CROSS_def"
-  "CROSS_EQ_EMPTY" > "HOLLight.hollight.CROSS_EQ_EMPTY"
-  "COUNTABLE_def" > "HOLLight.hollight.COUNTABLE_def"
-  "CONS_HD_TL" > "List.hd_Cons_tl"
-  "CONS_11" > "List.list.inject"
-  "CONSTR_def" > "HOLLight.hollight.CONSTR_def"
-  "CONSTR_REC" > "HOLLight.hollight.CONSTR_REC"
-  "CONSTR_INJ" > "HOLLight.hollight.CONSTR_INJ"
-  "CONSTR_IND" > "HOLLight.hollight.CONSTR_IND"
-  "CONSTR_BOT" > "HOLLight.hollight.CONSTR_BOT"
-  "CONJ_SYM" > "Groebner_Basis.dnf_3"
-  "CONJ_ASSOC" > "HOL.conj_ac_3"
-  "CONJ_ACI" > "HOLLight.hollight.CONJ_ACI"
-  "COND_RATOR" > "HOLLight.hollight.COND_RATOR"
-  "COND_RAND" > "HOL.if_distrib"
-  "COND_ID" > "HOL.if_cancel"
-  "COND_EXPAND" > "HOLLight.hollight.COND_EXPAND"
-  "COND_EQ_CLAUSE" > "HOLLight.hollight.COND_EQ_CLAUSE"
-  "COND_ELIM_THM" > "HOL.if_splits_1"
-  "COND_CLAUSES" > "HOLLight.hollight.COND_CLAUSES"
-  "COND_ABS" > "HOLLight.hollight.COND_ABS"
-  "COMPONENT" > "Set.insertI1"
-  "CHOOSE_SUBSET_STRONG" > "HOLLight.hollight.CHOOSE_SUBSET_STRONG"
-  "CHOOSE_SUBSET" > "HOLLight.hollight.CHOOSE_SUBSET"
-  "CHOICE_DEF" > "HOLLight.hollight.CHOICE_DEF"
-  "CASEWISE_def" > "HOLLight.hollight.CASEWISE_def"
-  "CART_EQ_FULL" > "HOLLight.hollight.CART_EQ_FULL"
-  "CART_EQ" > "HOLLight.hollight.CART_EQ"
-  "CARD_def" > "HOLLight.hollight.CARD_def"
-  "CARD_UNION_OVERLAP_EQ" > "HOLLight.hollight.CARD_UNION_OVERLAP_EQ"
-  "CARD_UNION_OVERLAP" > "HOLLight.hollight.CARD_UNION_OVERLAP"
-  "CARD_UNION_LE" > "HOLLight.hollight.CARD_UNION_LE"
-  "CARD_UNION_GEN" > "HOLLight.hollight.CARD_UNION_GEN"
-  "CARD_UNION_EQ" > "HOLLight.hollight.CARD_UNION_EQ"
-  "CARD_UNIONS_LE" > "HOLLight.hollight.CARD_UNIONS_LE"
-  "CARD_UNIONS" > "HOLLight.hollight.CARD_UNIONS"
-  "CARD_UNION" > "HOLLight.hollight.CARD_UNION"
-  "CARD_SUBSET_LE" > "HOLLight.hollight.CARD_SUBSET_LE"
-  "CARD_SUBSET_IMAGE" > "HOLLight.hollight.CARD_SUBSET_IMAGE"
-  "CARD_SUBSET_EQ" > "HOLLight.hollight.CARD_SUBSET_EQ"
-  "CARD_SUBSET" > "HOLLight.hollight.CARD_SUBSET"
-  "CARD_PSUBSET" > "HOLLight.hollight.CARD_PSUBSET"
-  "CARD_PRODUCT" > "HOLLight.hollight.CARD_PRODUCT"
-  "CARD_POWERSET" > "HOLLight.hollight.CARD_POWERSET"
-  "CARD_NUMSEG_LT" > "HOLLight.hollight.CARD_NUMSEG_LT"
-  "CARD_NUMSEG_LEMMA" > "HOLLight.hollight.CARD_NUMSEG_LEMMA"
-  "CARD_NUMSEG_LE" > "HOLLight.hollight.CARD_NUMSEG_LE"
-  "CARD_NUMSEG_1" > "HOLLight.hollight.CARD_NUMSEG_1"
-  "CARD_NUMSEG" > "HOLLight.hollight.CARD_NUMSEG"
-  "CARD_LE_INJ" > "HOLLight.hollight.CARD_LE_INJ"
-  "CARD_IMAGE_LE" > "HOLLight.hollight.CARD_IMAGE_LE"
-  "CARD_IMAGE_INJ_EQ" > "HOLLight.hollight.CARD_IMAGE_INJ_EQ"
-  "CARD_IMAGE_INJ" > "HOLLight.hollight.CARD_IMAGE_INJ"
-  "CARD_FUNSPACE" > "HOLLight.hollight.CARD_FUNSPACE"
-  "CARD_FINITE_IMAGE" > "HOLLight.hollight.CARD_FINITE_IMAGE"
-  "CARD_EQ_SUM" > "HOLLight.hollight.CARD_EQ_SUM"
-  "CARD_EQ_NSUM" > "HOLLight.hollight.CARD_EQ_NSUM"
-  "CARD_EQ_BIJECTIONS" > "HOLLight.hollight.CARD_EQ_BIJECTIONS"
-  "CARD_EQ_BIJECTION" > "HOLLight.hollight.CARD_EQ_BIJECTION"
-  "CARD_EQ_0" > "HOLLight.hollight.CARD_EQ_0"
-  "CARD_DIFF" > "HOLLight.hollight.CARD_DIFF"
-  "CARD_DELETE" > "HOLLight.hollight.CARD_DELETE"
-  "CARD_CROSS" > "HOLLight.hollight.CARD_CROSS"
-  "CARD_CLAUSES" > "HOLLight.hollight.CARD_CLAUSES"
-  "BOUNDS_NOTZERO" > "HOLLight.hollight.BOUNDS_NOTZERO"
-  "BOUNDS_LINEAR_0" > "HOLLight.hollight.BOUNDS_LINEAR_0"
-  "BOUNDS_LINEAR" > "HOLLight.hollight.BOUNDS_LINEAR"
-  "BOUNDS_IGNORE" > "HOLLight.hollight.BOUNDS_IGNORE"
-  "BOUNDS_DIVIDED" > "HOLLight.hollight.BOUNDS_DIVIDED"
-  "BOTTOM_def" > "HOLLight.hollight.BOTTOM_def"
-  "BOOL_CASES_AX" > "HOL.True_or_False"
-  "BIT1_THM" > "HOLLight.hollight.BIT1_THM"
-  "BIT1" > "HOLLight.hollight.BIT1"
-  "BIT0_THM" > "Int.semiring_mult_2"
-  "BIT0" > "Int.semiring_mult_2"
-  "BIJ_def" > "HOLLight.hollight.BIJ_def"
-  "BIJECTIVE_ON_LEFT_RIGHT_INVERSE" > "HOLLight.hollight.BIJECTIVE_ON_LEFT_RIGHT_INVERSE"
-  "BIJECTIVE_LEFT_RIGHT_INVERSE" > "HOLLight.hollight.BIJECTIVE_LEFT_RIGHT_INVERSE"
-  "BIJECTIONS_HAS_SIZE_EQ" > "HOLLight.hollight.BIJECTIONS_HAS_SIZE_EQ"
-  "BIJECTIONS_HAS_SIZE" > "HOLLight.hollight.BIJECTIONS_HAS_SIZE"
-  "BIJECTIONS_CARD_EQ" > "HOLLight.hollight.BIJECTIONS_CARD_EQ"
-  "BETA_THM" > "HOL.eta_contract_eq"
-  "ASCII_def" > "HOLLight.hollight.ASCII_def"
-  "ARITH_ZERO" > "HOLLight.hollight.ARITH_ZERO"
-  "ARITH_SUC" > "HOLLight.hollight.ARITH_SUC"
-  "ARITH_SUB" > "HOLLight.hollight.ARITH_SUB"
-  "ARITH_PRE" > "HOLLight.hollight.ARITH_PRE"
-  "ARITH_ODD" > "HOLLight.hollight.ARITH_ODD"
-  "ARITH_MULT" > "HOLLight.hollight.ARITH_MULT"
-  "ARITH_LT" > "HOLLight.hollight.ARITH_LT"
-  "ARITH_LE" > "HOLLight.hollight.ARITH_LE"
-  "ARITH_EXP" > "HOLLight.hollight.ARITH_EXP"
-  "ARITH_EVEN" > "HOLLight.hollight.ARITH_EVEN"
-  "ARITH_EQ" > "HOLLight.hollight.ARITH_EQ"
-  "ARITH_ADD" > "HOLLight.hollight.ARITH_ADD"
-  "APPEND_NIL" > "List.append_Nil2"
-  "APPEND_EQ_NIL" > "List.append_is_Nil_conv"
-  "APPEND_BUTLAST_LAST" > "List.append_butlast_last_id"
-  "APPEND_ASSOC" > "List.append_assoc"
-  "AND_FORALL_THM" > "HOL.all_conj_distrib"
-  "AND_CLAUSES" > "HOLLight.hollight.AND_CLAUSES"
-  "AND_ALL2" > "HOLLightList.AND_ALL2"
-  "AND_ALL" > "HOLLightList.AND_ALL"
-  "ALL_T" > "HOLLightList.ALL_T"
-  "ALL_MP" > "HOLLightList.ALL_MP"
-  "ALL_MEM" > "HOLLightList.ALL_MEM"
-  "ALL_IMP" > "HOLLightList.ALL_IMP"
-  "ALL_EL" > "List.list_all_length"
-  "ALL_APPEND" > "List.list_all_append"
-  "ALL2_MAP2" > "HOLLightList.ALL2_MAP2"
-  "ALL2_MAP" > "HOLLightList.ALL2_MAP"
-  "ALL2_AND_RIGHT" > "HOLLightList.ALL2_AND_RIGHT"
-  "ALL2_ALL" > "HOLLightList.ALL2_ALL"
-  "ALL2" > "HOLLightList.ALL2"
-  "ADMISSIBLE_UNGUARDED_PATTERN" > "HOLLight.hollight.ADMISSIBLE_UNGUARDED_PATTERN"
-  "ADMISSIBLE_SUM" > "HOLLight.hollight.ADMISSIBLE_SUM"
-  "ADMISSIBLE_SEQPATTERN" > "HOLLight.hollight.ADMISSIBLE_SEQPATTERN"
-  "ADMISSIBLE_RAND" > "HOLLight.hollight.ADMISSIBLE_RAND"
-  "ADMISSIBLE_NSUM" > "HOLLight.hollight.ADMISSIBLE_NSUM"
-  "ADMISSIBLE_NEST" > "HOLLight.hollight.ADMISSIBLE_NEST"
-  "ADMISSIBLE_MATCH_SEQPATTERN" > "HOLLight.hollight.ADMISSIBLE_MATCH_SEQPATTERN"
-  "ADMISSIBLE_MATCH" > "HOLLight.hollight.ADMISSIBLE_MATCH"
-  "ADMISSIBLE_MAP" > "HOLLight.hollight.ADMISSIBLE_MAP"
-  "ADMISSIBLE_LAMBDA" > "HOLLight.hollight.ADMISSIBLE_LAMBDA"
-  "ADMISSIBLE_IMP_SUPERADMISSIBLE" > "HOLLight.hollight.ADMISSIBLE_IMP_SUPERADMISSIBLE"
-  "ADMISSIBLE_GUARDED_PATTERN" > "HOLLight.hollight.ADMISSIBLE_GUARDED_PATTERN"
-  "ADMISSIBLE_CONST" > "HOLLight.hollight.ADMISSIBLE_CONST"
-  "ADMISSIBLE_COND" > "HOLLight.hollight.ADMISSIBLE_COND"
-  "ADMISSIBLE_COMB" > "HOLLight.hollight.ADMISSIBLE_COMB"
-  "ADMISSIBLE_BASE" > "HOLLight.hollight.ADMISSIBLE_BASE"
-  "ADD_SYM" > "Fields.linordered_field_class.sign_simps_43"
-  "ADD_SUC" > "Nat.add_Suc_right"
-  "ADD_SUBR2" > "Nat.diff_add_0"
-  "ADD_SUBR" > "HOLLight.hollight.ADD_SUBR"
-  "ADD_SUB2" > "Nat.diff_add_inverse"
-  "ADD_SUB" > "Nat.diff_add_inverse2"
-  "ADD_EQ_0" > "Nat.add_is_0"
-  "ADD_CLAUSES" > "HOLLight.hollight.ADD_CLAUSES"
-  "ADD_ASSOC" > "Fields.linordered_field_class.sign_simps_44"
-  "ADD_AC" > "HOLLight.hollight.ADD_AC"
-  "ADD_0" > "Divides.arithmetic_simps_39"
-  "ADD1" > "Nat_Numeral.Suc_eq_plus1"
-  "ABS_SIMP" > "HOL.refl"
-  "ABSORPTION" > "HOLLight.hollight.ABSORPTION"
-  ">_c_def" > "HOLLight.hollight.>_c_def"
-  ">=_c_def" > "HOLLight.hollight.>=_c_def"
-  "=_c_def" > "HOLLight.hollight.=_c_def"
-  "<_c_def" > "HOLLight.hollight.<_c_def"
-  "<=_c_def" > "HOLLight.hollight.<=_c_def"
-  "$_def" > "HOLLight.hollight.$_def"
-
-ignore_thms
-  "WF_REC_CASES"
-  "TYDEF_sum"
-  "TYDEF_prod"
-  "TYDEF_option"
-  "TYDEF_num"
-  "TYDEF_list"
-  "TYDEF_1"
-  "SNDCART_PASTECART"
-  "SET_OF_LIST_OF_SET"
-  "REP_ABS_PAIR"
-  "RECURSION_CASEWISE_PAIRWISE"
-  "RECURSION_CASEWISE"
-  "PASTECART_FST_SND"
-  "PASTECART_EQ"
-  "MEM_LIST_OF_SET"
-  "MEM_ASSOC"
-  "LIST_OF_SET_PROPERTIES"
-  "LENGTH_LIST_OF_SET"
-  "HAS_SIZE_SET_OF_LIST"
-  "FSTCART_PASTECART"
-  "FORALL_PASTECART"
-  "FINITE_SET_OF_LIST"
-  "EX_MAP"
-  "EXISTS_PASTECART"
-  "EL_TL"
-  "DIMINDEX_HAS_SIZE_FINITE_SUM"
-  "DIMINDEX_FINITE_SUM"
-  "DEF_one"
-  "DEF_mk_pair"
-  "DEF_list_of_set"
-  "DEF__0"
-  "DEF_ZIP"
-  "DEF_TL"
-  "DEF_SUC"
-  "DEF_SOME"
-  "DEF_OUTR"
-  "DEF_OUTL"
-  "DEF_NONE"
-  "DEF_NIL"
-  "DEF_MAP2"
-  "DEF_ITLIST2"
-  "DEF_INR"
-  "DEF_INL"
-  "DEF_HD"
-  "DEF_CONS"
-  "DEF_ASSOC"
-  "DEF_,"
-  "CASEWISE_WORKS"
-  "CASEWISE_CASES"
-  "CASEWISE"
-  "CARD_SET_OF_LIST_LE"
-  "ALL_MAP"
-
-end
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL_Light/Generated/HOLLight.thy
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL_Light/Generated/HOLLight.thy	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,7472 @@
+(* AUTOMATICALLY GENERATED, DO NOT EDIT! *)
+
+theory HOLLight
+imports "../../HOL4Syntax" "../Compatibility"
+begin 
+
+setup_theory "~~/src/HOL/Import/HOL_Light/Generated" hollight
+
+consts
+  "_FALSITY_" :: "bool" ("'_FALSITY'_")
+
+defs
+  "_FALSITY__def": "_FALSITY_ == False"
+
+lemma DEF__FALSITY_: "_FALSITY_ = False"
+  by (import hollight DEF__FALSITY_)
+
+lemma CONJ_ACI: "(p & q) = (q & p) &
+((p & q) & r) = (p & q & r) &
+(p & q & r) = (q & p & r) & (p & p) = p & (p & p & q) = (p & q)"
+  by (import hollight CONJ_ACI)
+
+lemma DISJ_ACI: "(p | q) = (q | p) &
+((p | q) | r) = (p | q | r) &
+(p | q | r) = (q | p | r) & (p | p) = p & (p | p | q) = (p | q)"
+  by (import hollight DISJ_ACI)
+
+lemma IMP_CONJ_ALT: "(p & q --> r) = (q --> p --> r)"
+  by (import hollight IMP_CONJ_ALT)
+
+lemma EQ_CLAUSES: "(True = t) = t & (t = True) = t & (False = t) = (~ t) & (t = False) = (~ t)"
+  by (import hollight EQ_CLAUSES)
+
+lemma NOT_CLAUSES_WEAK: "(~ True) = False & (~ False) = True"
+  by (import hollight NOT_CLAUSES_WEAK)
+
+lemma AND_CLAUSES: "(True & t) = t &
+(t & True) = t & (False & t) = False & (t & False) = False & (t & t) = t"
+  by (import hollight AND_CLAUSES)
+
+lemma OR_CLAUSES: "(True | t) = True &
+(t | True) = True & (False | t) = t & (t | False) = t & (t | t) = t"
+  by (import hollight OR_CLAUSES)
+
+lemma IMP_CLAUSES: "(True --> t) = t &
+(t --> True) = True &
+(False --> t) = True & (t --> t) = True & (t --> False) = (~ t)"
+  by (import hollight IMP_CLAUSES)
+
+lemma IMP_EQ_CLAUSE: "((x::'q_851) = x --> (p::bool)) = p"
+  by (import hollight IMP_EQ_CLAUSE)
+
+lemma TRIV_EXISTS_AND_THM: "(EX x::'A. (P::bool) & (Q::bool)) = ((EX x::'A. P) & (EX x::'A. Q))"
+  by (import hollight TRIV_EXISTS_AND_THM)
+
+lemma TRIV_AND_EXISTS_THM: "((EX x::'A. (P::bool)) & (EX x::'A. (Q::bool))) = (EX x::'A. P & Q)"
+  by (import hollight TRIV_AND_EXISTS_THM)
+
+lemma TRIV_FORALL_OR_THM: "(ALL x::'A. (P::bool) | (Q::bool)) = ((ALL x::'A. P) | (ALL x::'A. Q))"
+  by (import hollight TRIV_FORALL_OR_THM)
+
+lemma TRIV_OR_FORALL_THM: "((ALL x::'A. (P::bool)) | (ALL x::'A. (Q::bool))) = (ALL x::'A. P | Q)"
+  by (import hollight TRIV_OR_FORALL_THM)
+
+lemma TRIV_FORALL_IMP_THM: "(ALL x::'A. (P::bool) --> (Q::bool)) = ((EX x::'A. P) --> (ALL x::'A. Q))"
+  by (import hollight TRIV_FORALL_IMP_THM)
+
+lemma TRIV_EXISTS_IMP_THM: "(EX x::'A. (P::bool) --> (Q::bool)) = ((ALL x::'A. P) --> (EX x::'A. Q))"
+  by (import hollight TRIV_EXISTS_IMP_THM)
+
+lemma EXISTS_UNIQUE_ALT: "Ex1 (P::'A => bool) = (EX x::'A. ALL y::'A. P y = (x = y))"
+  by (import hollight EXISTS_UNIQUE_ALT)
+
+lemma SELECT_UNIQUE: "(!!y::'A. (P::'A => bool) y = (y = (x::'A))) ==> Eps P = x"
+  by (import hollight SELECT_UNIQUE)
+
+lemma EXCLUDED_MIDDLE: "t | ~ t"
+  by (import hollight EXCLUDED_MIDDLE)
+
+lemma COND_CLAUSES: "(if True then x::'A else (xa::'A)) = x & (if False then x else xa) = xa"
+  by (import hollight COND_CLAUSES)
+
+lemma COND_EXPAND: "(if b then t1 else t2) = ((~ b | t1) & (b | t2))"
+  by (import hollight COND_EXPAND)
+
+lemma COND_RATOR: "(if b::bool then f::'A => 'B else (g::'A => 'B)) (x::'A) =
+(if b then f x else g x)"
+  by (import hollight COND_RATOR)
+
+lemma COND_ABS: "(%x::'A. if b::bool then (f::'A => 'B) x else (g::'A => 'B) x) =
+(if b then f else g)"
+  by (import hollight COND_ABS)
+
+lemma MONO_COND: "[| (A --> B) & (C --> D); if b then A else C |] ==> if b then B else D"
+  by (import hollight MONO_COND)
+
+lemma SKOLEM_THM: "(ALL x::'A. Ex ((P::'A => 'B => bool) x)) =
+(EX x::'A => 'B. ALL xa::'A. P xa (x xa))"
+  by (import hollight SKOLEM_THM)
+
+lemma UNIQUE_SKOLEM_ALT: "(ALL x::'A. Ex1 ((P::'A => 'B => bool) x)) =
+(EX f::'A => 'B. ALL (x::'A) y::'B. P x y = (f x = y))"
+  by (import hollight UNIQUE_SKOLEM_ALT)
+
+lemma COND_EQ_CLAUSE: "(if (x::'q_2963) = x then y::'q_2956 else (z::'q_2956)) = y"
+  by (import hollight COND_EQ_CLAUSE)
+
+lemma bool_RECURSION: "EX x::bool => 'A. x False = (a::'A) & x True = (b::'A)"
+  by (import hollight bool_RECURSION)
+
+lemma o_ASSOC: "(f::'C => 'D) o ((g::'B => 'C) o (h::'A => 'B)) = f o g o h"
+  by (import hollight o_ASSOC)
+
+lemma I_O_ID: "id o (f::'A => 'B) = f & f o id = f"
+  by (import hollight I_O_ID)
+
+lemma EXISTS_ONE_REP: "EX x. x"
+  by (import hollight EXISTS_ONE_REP)
+
+lemma one_axiom: "(f::'A => unit) = (x::'A => unit)"
+  by (import hollight one_axiom)
+
+lemma one_RECURSION: "EX x::unit => 'A. x () = (e::'A)"
+  by (import hollight one_RECURSION)
+
+lemma one_Axiom: "EX! fn::unit => 'A. fn () = (e::'A)"
+  by (import hollight one_Axiom)
+
+lemma th_cond: "(b = False --> x = x0) & (b = True --> x = x1) ==> x = (b & x1 | ~ b & x0)"
+  by (import hollight th_cond)
+
+definition
+  LET_END :: "'A => 'A"  where
+  "LET_END == %t::'A. t"
+
+lemma DEF_LET_END: "LET_END = (%t::'A. t)"
+  by (import hollight DEF_LET_END)
+
+consts
+  "_SEQPATTERN" :: "('q_4007 => 'q_4004 => bool)
+=> ('q_4007 => 'q_4004 => bool) => 'q_4007 => 'q_4004 => bool" ("'_SEQPATTERN")
+
+defs
+  "_SEQPATTERN_def": "_SEQPATTERN ==
+%(r::'q_4007 => 'q_4004 => bool) (s::'q_4007 => 'q_4004 => bool) x::'q_4007.
+   if Ex (r x) then r x else s x"
+
+lemma DEF__SEQPATTERN: "_SEQPATTERN =
+(%(r::'q_4007 => 'q_4004 => bool) (s::'q_4007 => 'q_4004 => bool)
+    x::'q_4007. if Ex (r x) then r x else s x)"
+  by (import hollight DEF__SEQPATTERN)
+
+consts
+  "_UNGUARDED_PATTERN" :: "bool => bool => bool" ("'_UNGUARDED'_PATTERN")
+
+defs
+  "_UNGUARDED_PATTERN_def": "_UNGUARDED_PATTERN == op &"
+
+lemma DEF__UNGUARDED_PATTERN: "_UNGUARDED_PATTERN = op &"
+  by (import hollight DEF__UNGUARDED_PATTERN)
+
+consts
+  "_GUARDED_PATTERN" :: "bool => bool => bool => bool" ("'_GUARDED'_PATTERN")
+
+defs
+  "_GUARDED_PATTERN_def": "_GUARDED_PATTERN == %p g r. p & g & r"
+
+lemma DEF__GUARDED_PATTERN: "_GUARDED_PATTERN = (%p g r. p & g & r)"
+  by (import hollight DEF__GUARDED_PATTERN)
+
+consts
+  "_MATCH" :: "'q_4049 => ('q_4049 => 'q_4053 => bool) => 'q_4053" ("'_MATCH")
+
+defs
+  "_MATCH_def": "_MATCH ==
+%(e::'q_4049) r::'q_4049 => 'q_4053 => bool.
+   if Ex1 (r e) then Eps (r e) else SOME z::'q_4053. False"
+
+lemma DEF__MATCH: "_MATCH =
+(%(e::'q_4049) r::'q_4049 => 'q_4053 => bool.
+    if Ex1 (r e) then Eps (r e) else SOME z::'q_4053. False)"
+  by (import hollight DEF__MATCH)
+
+consts
+  "_FUNCTION" :: "('q_4071 => 'q_4075 => bool) => 'q_4071 => 'q_4075" ("'_FUNCTION")
+
+defs
+  "_FUNCTION_def": "_FUNCTION ==
+%(r::'q_4071 => 'q_4075 => bool) x::'q_4071.
+   if Ex1 (r x) then Eps (r x) else SOME z::'q_4075. False"
+
+lemma DEF__FUNCTION: "_FUNCTION =
+(%(r::'q_4071 => 'q_4075 => bool) x::'q_4071.
+    if Ex1 (r x) then Eps (r x) else SOME z::'q_4075. False)"
+  by (import hollight DEF__FUNCTION)
+
+lemma PAIR_EXISTS_THM: "EX (x::'A => 'B => bool) (a::'A) b::'B. x = Pair_Rep a b"
+  by (import hollight PAIR_EXISTS_THM)
+
+lemma pair_RECURSION: "EX x::'A * 'B => 'C.
+   ALL (a0::'A) a1::'B. x (a0, a1) = (PAIR'::'A => 'B => 'C) a0 a1"
+  by (import hollight pair_RECURSION)
+
+definition
+  UNCURRY :: "('A => 'B => 'C) => 'A * 'B => 'C"  where
+  "UNCURRY == %(u::'A => 'B => 'C) ua::'A * 'B. u (fst ua) (snd ua)"
+
+lemma DEF_UNCURRY: "UNCURRY = (%(u::'A => 'B => 'C) ua::'A * 'B. u (fst ua) (snd ua))"
+  by (import hollight DEF_UNCURRY)
+
+definition
+  PASSOC :: "(('A * 'B) * 'C => 'D) => 'A * 'B * 'C => 'D"  where
+  "PASSOC ==
+%(u::('A * 'B) * 'C => 'D) ua::'A * 'B * 'C.
+   u ((fst ua, fst (snd ua)), snd (snd ua))"
+
+lemma DEF_PASSOC: "PASSOC =
+(%(u::('A * 'B) * 'C => 'D) ua::'A * 'B * 'C.
+    u ((fst ua, fst (snd ua)), snd (snd ua)))"
+  by (import hollight DEF_PASSOC)
+
+lemma LAMBDA_PAIR_THM: "(x::'q_4547 * 'q_4546 => 'q_4539) =
+(SOME f::'q_4547 * 'q_4546 => 'q_4539.
+    ALL (xa::'q_4547) y::'q_4546. f (xa, y) = x (xa, y))"
+  by (import hollight LAMBDA_PAIR_THM)
+
+lemma FORALL_PAIRED_THM: "All (SOME f::'q_4576 * 'q_4575 => bool.
+        ALL (x::'q_4576) y::'q_4575.
+           f (x, y) = (P::'q_4576 => 'q_4575 => bool) x y) =
+(ALL x::'q_4576. All (P x))"
+  by (import hollight FORALL_PAIRED_THM)
+
+lemma EXISTS_PAIRED_THM: "Ex (SOME f::'q_4612 * 'q_4611 => bool.
+       ALL (x::'q_4612) y::'q_4611.
+          f (x, y) = (P::'q_4612 => 'q_4611 => bool) x y) =
+(EX x::'q_4612. Ex (P x))"
+  by (import hollight EXISTS_PAIRED_THM)
+
+lemma FORALL_TRIPLED_THM: "All (SOME f::'q_4649 * 'q_4648 * 'q_4647 => bool.
+        ALL (x::'q_4649) (y::'q_4648) z::'q_4647.
+           f (x, y, z) = (P::'q_4649 => 'q_4648 => 'q_4647 => bool) x y z) =
+(ALL (x::'q_4649) y::'q_4648. All (P x y))"
+  by (import hollight FORALL_TRIPLED_THM)
+
+lemma EXISTS_TRIPLED_THM: "Ex (SOME f::'q_4695 * 'q_4694 * 'q_4693 => bool.
+       ALL (x::'q_4695) (y::'q_4694) z::'q_4693.
+          f (x, y, z) = (P::'q_4695 => 'q_4694 => 'q_4693 => bool) x y z) =
+(EX (x::'q_4695) y::'q_4694. Ex (P x y))"
+  by (import hollight EXISTS_TRIPLED_THM)
+
+lemma IND_SUC_0_EXISTS: "EX (x::ind => ind) z::ind.
+   (ALL (x1::ind) x2::ind. (x x1 = x x2) = (x1 = x2)) &
+   (ALL xa::ind. x xa ~= z)"
+  by (import hollight IND_SUC_0_EXISTS)
+
+definition
+  IND_SUC :: "ind => ind"  where
+  "IND_SUC ==
+SOME f. EX z. (ALL x1 x2. (f x1 = f x2) = (x1 = x2)) & (ALL x. f x ~= z)"
+
+lemma DEF_IND_SUC: "IND_SUC =
+(SOME f. EX z. (ALL x1 x2. (f x1 = f x2) = (x1 = x2)) & (ALL x. f x ~= z))"
+  by (import hollight DEF_IND_SUC)
+
+definition
+  IND_0 :: "ind"  where
+  "IND_0 ==
+SOME z.
+   (ALL x1 x2. (IND_SUC x1 = IND_SUC x2) = (x1 = x2)) &
+   (ALL x. IND_SUC x ~= z)"
+
+lemma DEF_IND_0: "IND_0 =
+(SOME z.
+    (ALL x1 x2. (IND_SUC x1 = IND_SUC x2) = (x1 = x2)) &
+    (ALL x. IND_SUC x ~= z))"
+  by (import hollight DEF_IND_0)
+
+definition
+  NUM_REP :: "ind => bool"  where
+  "NUM_REP ==
+%a. ALL NUM_REP'.
+       (ALL a.
+           a = IND_0 | (EX i. a = IND_SUC i & NUM_REP' i) -->
+           NUM_REP' a) -->
+       NUM_REP' a"
+
+lemma DEF_NUM_REP: "NUM_REP =
+(%a. ALL NUM_REP'.
+        (ALL a.
+            a = IND_0 | (EX i. a = IND_SUC i & NUM_REP' i) -->
+            NUM_REP' a) -->
+        NUM_REP' a)"
+  by (import hollight DEF_NUM_REP)
+
+lemma num_RECURSION_STD: "EX fn::nat => 'Z.
+   fn (0::nat) = (e::'Z) &
+   (ALL n::nat. fn (Suc n) = (f::nat => 'Z => 'Z) n (fn n))"
+  by (import hollight num_RECURSION_STD)
+
+lemma ADD_CLAUSES: "(ALL x::nat. (0::nat) + x = x) &
+(ALL x::nat. x + (0::nat) = x) &
+(ALL (x::nat) xa::nat. Suc x + xa = Suc (x + xa)) &
+(ALL (x::nat) xa::nat. x + Suc xa = Suc (x + xa))"
+  by (import hollight ADD_CLAUSES)
+
+lemma ADD_AC: "(m::nat) + (n::nat) = n + m &
+m + n + (p::nat) = m + (n + p) & m + (n + p) = n + (m + p)"
+  by (import hollight ADD_AC)
+
+lemma EQ_ADD_LCANCEL_0: "((m::nat) + (n::nat) = m) = (n = (0::nat))"
+  by (import hollight EQ_ADD_LCANCEL_0)
+
+lemma EQ_ADD_RCANCEL_0: "((x::nat) + (xa::nat) = xa) = (x = (0::nat))"
+  by (import hollight EQ_ADD_RCANCEL_0)
+
+lemma BIT1: "2 * x + 1 = Suc (x + x)"
+  by (import hollight BIT1)
+
+lemma BIT1_THM: "2 * x + 1 = Suc (x + x)"
+  by (import hollight BIT1_THM)
+
+lemma TWO: "2 = Suc 1"
+  by (import hollight TWO)
+
+lemma MULT_CLAUSES: "(ALL x::nat. (0::nat) * x = (0::nat)) &
+(ALL x::nat. x * (0::nat) = (0::nat)) &
+(ALL x::nat. (1::nat) * x = x) &
+(ALL x::nat. x * (1::nat) = x) &
+(ALL (x::nat) xa::nat. Suc x * xa = x * xa + xa) &
+(ALL (x::nat) xa::nat. x * Suc xa = x + x * xa)"
+  by (import hollight MULT_CLAUSES)
+
+lemma MULT_AC: "(m::nat) * (n::nat) = n * m &
+m * n * (p::nat) = m * (n * p) & m * (n * p) = n * (m * p)"
+  by (import hollight MULT_AC)
+
+lemma EXP_EQ_1: "((x::nat) ^ (n::nat) = (1::nat)) = (x = (1::nat) | n = (0::nat))"
+  by (import hollight EXP_EQ_1)
+
+lemma LT_ANTISYM: "~ ((m::nat) < (n::nat) & n < m)"
+  by (import hollight LT_ANTISYM)
+
+lemma LET_ANTISYM: "~ ((m::nat) <= (n::nat) & n < m)"
+  by (import hollight LET_ANTISYM)
+
+lemma LTE_ANTISYM: "~ ((x::nat) < (xa::nat) & xa <= x)"
+  by (import hollight LTE_ANTISYM)
+
+lemma LT_CASES: "(m::nat) < (n::nat) | n < m | m = n"
+  by (import hollight LT_CASES)
+
+lemma LTE_CASES: "(x::nat) < (xa::nat) | xa <= x"
+  by (import hollight LTE_CASES)
+
+lemma LE_1: "(ALL x::nat. x ~= (0::nat) --> (0::nat) < x) &
+(ALL x::nat. x ~= (0::nat) --> (1::nat) <= x) &
+(ALL x>0::nat. x ~= (0::nat)) &
+(ALL x>0::nat. (1::nat) <= x) &
+(ALL x>=1::nat. (0::nat) < x) & (ALL x>=1::nat. x ~= (0::nat))"
+  by (import hollight LE_1)
+
+lemma LT_EXISTS: "(m < n) = (EX d. n = m + Suc d)"
+  by (import hollight LT_EXISTS)
+
+lemma LT_ADD: "((m::nat) < m + (n::nat)) = ((0::nat) < n)"
+  by (import hollight LT_ADD)
+
+lemma LT_ADDR: "((xa::nat) < (x::nat) + xa) = ((0::nat) < x)"
+  by (import hollight LT_ADDR)
+
+lemma LT_LMULT: "(m::nat) ~= (0::nat) & (n::nat) < (p::nat) ==> m * n < m * p"
+  by (import hollight LT_LMULT)
+
+lemma LE_MULT_LCANCEL: "((m::nat) * (n::nat) <= m * (p::nat)) = (m = (0::nat) | n <= p)"
+  by (import hollight LE_MULT_LCANCEL)
+
+lemma LE_MULT_RCANCEL: "((x::nat) * (xb::nat) <= (xa::nat) * xb) = (x <= xa | xb = (0::nat))"
+  by (import hollight LE_MULT_RCANCEL)
+
+lemma LT_MULT_LCANCEL: "((m::nat) * (n::nat) < m * (p::nat)) = (m ~= (0::nat) & n < p)"
+  by (import hollight LT_MULT_LCANCEL)
+
+lemma LT_MULT_RCANCEL: "((x::nat) * (xb::nat) < (xa::nat) * xb) = (x < xa & xb ~= (0::nat))"
+  by (import hollight LT_MULT_RCANCEL)
+
+lemma LT_MULT2: "(m::nat) < (n::nat) & (p::nat) < (q::nat) ==> m * p < n * q"
+  by (import hollight LT_MULT2)
+
+lemma WLOG_LE: "(ALL (m::nat) n::nat. (P::nat => nat => bool) m n = P n m) &
+(ALL (m::nat) n::nat. m <= n --> P m n)
+==> P (m::nat) (x::nat)"
+  by (import hollight WLOG_LE)
+
+lemma WLOG_LT: "(ALL m::nat. (P::nat => nat => bool) m m) &
+(ALL (m::nat) n::nat. P m n = P n m) &
+(ALL (m::nat) n::nat. m < n --> P m n)
+==> P (m::nat) (x::nat)"
+  by (import hollight WLOG_LT)
+
+lemma num_WOP: "Ex (P::nat => bool) = (EX n::nat. P n & (ALL m<n. ~ P m))"
+  by (import hollight num_WOP)
+
+lemma num_MAX: "(Ex (P::nat => bool) & (EX M::nat. ALL x::nat. P x --> x <= M)) =
+(EX m::nat. P m & (ALL x::nat. P x --> x <= m))"
+  by (import hollight num_MAX)
+
+lemma NOT_EVEN: "odd (n::nat) = odd n"
+  by (import hollight NOT_EVEN)
+
+lemma NOT_ODD: "(~ odd (n::nat)) = even n"
+  by (import hollight NOT_ODD)
+
+lemma EVEN_OR_ODD: "even (n::nat) | odd n"
+  by (import hollight EVEN_OR_ODD)
+
+lemma EVEN_AND_ODD: "~ (even (x::nat) & odd x)"
+  by (import hollight EVEN_AND_ODD)
+
+lemma EVEN_EXP: "even ((m::nat) ^ (n::nat)) = (even m & n ~= (0::nat))"
+  by (import hollight EVEN_EXP)
+
+lemma ODD_MULT: "odd ((m::nat) * (n::nat)) = (odd m & odd n)"
+  by (import hollight ODD_MULT)
+
+lemma ODD_EXP: "odd ((m::nat) ^ (n::nat)) = (odd m | n = (0::nat))"
+  by (import hollight ODD_EXP)
+
+lemma EVEN_DOUBLE: "even ((2::nat) * (n::nat))"
+  by (import hollight EVEN_DOUBLE)
+
+lemma ODD_DOUBLE: "odd (Suc (2 * x))"
+  by (import hollight ODD_DOUBLE)
+
+lemma EVEN_EXISTS_LEMMA: "(even n --> (EX m. n = 2 * m)) & (odd n --> (EX m. n = Suc (2 * m)))"
+  by (import hollight EVEN_EXISTS_LEMMA)
+
+lemma EVEN_ODD_DECOMPOSITION: "(EX (k::nat) m::nat. odd m & (n::nat) = (2::nat) ^ k * m) = (n ~= (0::nat))"
+  by (import hollight EVEN_ODD_DECOMPOSITION)
+
+lemma SUB_0: "(0::nat) - (x::nat) = (0::nat) & x - (0::nat) = x"
+  by (import hollight SUB_0)
+
+lemma SUB_PRESUC: "Suc m - n - Suc 0 = m - n"
+  by (import hollight SUB_PRESUC)
+
+lemma ADD_SUBR: "(xa::nat) - ((x::nat) + xa) = (0::nat)"
+  by (import hollight ADD_SUBR)
+
+lemma EVEN_SUB: "even ((m::nat) - (n::nat)) = (m <= n | even m = even n)"
+  by (import hollight EVEN_SUB)
+
+lemma ODD_SUB: "odd ((x::nat) - (xa::nat)) = (xa < x & odd x ~= odd xa)"
+  by (import hollight ODD_SUB)
+
+lemma EXP_LT_0: "((0::nat) < (xa::nat) ^ (x::nat)) = (xa ~= (0::nat) | x = (0::nat))"
+  by (import hollight EXP_LT_0)
+
+lemma LT_EXP: "((x::nat) ^ (m::nat) < x ^ (n::nat)) =
+((2::nat) <= x & m < n | x = (0::nat) & m ~= (0::nat) & n = (0::nat))"
+  by (import hollight LT_EXP)
+
+lemma LE_EXP: "((x::nat) ^ (m::nat) <= x ^ (n::nat)) =
+(if x = (0::nat) then m = (0::nat) --> n = (0::nat)
+ else x = (1::nat) | m <= n)"
+  by (import hollight LE_EXP)
+
+lemma EQ_EXP: "((x::nat) ^ (m::nat) = x ^ (n::nat)) =
+(if x = (0::nat) then (m = (0::nat)) = (n = (0::nat))
+ else x = (1::nat) | m = n)"
+  by (import hollight EQ_EXP)
+
+lemma EXP_MONO_LE_IMP: "(x::nat) <= (xa::nat) ==> x ^ (xb::nat) <= xa ^ xb"
+  by (import hollight EXP_MONO_LE_IMP)
+
+lemma EXP_MONO_LT_IMP: "(x::nat) < (y::nat) & (n::nat) ~= (0::nat) ==> x ^ n < y ^ n"
+  by (import hollight EXP_MONO_LT_IMP)
+
+lemma EXP_MONO_LE: "((x::nat) ^ (n::nat) <= (y::nat) ^ n) = (x <= y | n = (0::nat))"
+  by (import hollight EXP_MONO_LE)
+
+lemma EXP_MONO_LT: "((x::nat) ^ (xb::nat) < (xa::nat) ^ xb) = (x < xa & xb ~= (0::nat))"
+  by (import hollight EXP_MONO_LT)
+
+lemma EXP_MONO_EQ: "((x::nat) ^ (xb::nat) = (xa::nat) ^ xb) = (x = xa | xb = (0::nat))"
+  by (import hollight EXP_MONO_EQ)
+
+lemma DIVMOD_EXIST: "(n::nat) ~= (0::nat) ==> EX (q::nat) r::nat. (m::nat) = q * n + r & r < n"
+  by (import hollight DIVMOD_EXIST)
+
+lemma DIVMOD_EXIST_0: "EX (x::nat) xa::nat.
+   if (n::nat) = (0::nat) then x = (0::nat) & xa = (m::nat)
+   else m = x * n + xa & xa < n"
+  by (import hollight DIVMOD_EXIST_0)
+
+lemma DIVISION: "(n::nat) ~= (0::nat) ==> (m::nat) = m div n * n + m mod n & m mod n < n"
+  by (import hollight DIVISION)
+
+lemma DIVMOD_UNIQ_LEMMA: "((m::nat) = (q1::nat) * (n::nat) + (r1::nat) & r1 < n) &
+m = (q2::nat) * n + (r2::nat) & r2 < n
+==> q1 = q2 & r1 = r2"
+  by (import hollight DIVMOD_UNIQ_LEMMA)
+
+lemma DIVMOD_UNIQ: "(m::nat) = (q::nat) * (n::nat) + (r::nat) & r < n
+==> m div n = q & m mod n = r"
+  by (import hollight DIVMOD_UNIQ)
+
+lemma MOD_UNIQ: "(m::nat) = (q::nat) * (n::nat) + (r::nat) & r < n ==> m mod n = r"
+  by (import hollight MOD_UNIQ)
+
+lemma DIV_UNIQ: "(m::nat) = (q::nat) * (n::nat) + (r::nat) & r < n ==> m div n = q"
+  by (import hollight DIV_UNIQ)
+
+lemma MOD_EQ: "(m::nat) = (n::nat) + (q::nat) * (p::nat) ==> m mod p = n mod p"
+  by (import hollight MOD_EQ)
+
+lemma DIV_LE: "(n::nat) ~= (0::nat) ==> (m::nat) div n <= m"
+  by (import hollight DIV_LE)
+
+lemma DIV_MUL_LE: "(n::nat) * ((m::nat) div n) <= m"
+  by (import hollight DIV_MUL_LE)
+
+lemma MOD_MOD: "(n::nat) * (p::nat) ~= (0::nat) ==> (m::nat) mod (n * p) mod n = m mod n"
+  by (import hollight MOD_MOD)
+
+lemma MOD_MOD_REFL: "(n::nat) ~= (0::nat) ==> (m::nat) mod n mod n = m mod n"
+  by (import hollight MOD_MOD_REFL)
+
+lemma DIV_MULT2: "(x::nat) * (xb::nat) ~= (0::nat) ==> x * (xa::nat) div (x * xb) = xa div xb"
+  by (import hollight DIV_MULT2)
+
+lemma MOD_MULT2: "(x::nat) * (xb::nat) ~= (0::nat)
+==> x * (xa::nat) mod (x * xb) = x * (xa mod xb)"
+  by (import hollight MOD_MULT2)
+
+lemma MOD_EXISTS: "(EX q::nat. (m::nat) = (n::nat) * q) =
+(if n = (0::nat) then m = (0::nat) else m mod n = (0::nat))"
+  by (import hollight MOD_EXISTS)
+
+lemma LE_RDIV_EQ: "(a::nat) ~= (0::nat) ==> ((n::nat) <= (b::nat) div a) = (a * n <= b)"
+  by (import hollight LE_RDIV_EQ)
+
+lemma LE_LDIV_EQ: "(a::nat) ~= (0::nat)
+==> ((b::nat) div a <= (n::nat)) = (b < a * (n + (1::nat)))"
+  by (import hollight LE_LDIV_EQ)
+
+lemma LE_LDIV: "(x::nat) ~= (0::nat) & (xa::nat) <= x * (xb::nat) ==> xa div x <= xb"
+  by (import hollight LE_LDIV)
+
+lemma DIV_MONO: "(p::nat) ~= (0::nat) & (m::nat) <= (n::nat) ==> m div p <= n div p"
+  by (import hollight DIV_MONO)
+
+lemma DIV_MONO_LT: "(p::nat) ~= (0::nat) & (m::nat) + p <= (n::nat) ==> m div p < n div p"
+  by (import hollight DIV_MONO_LT)
+
+lemma DIV_EQ_0: "(n::nat) ~= (0::nat) ==> ((m::nat) div n = (0::nat)) = (m < n)"
+  by (import hollight DIV_EQ_0)
+
+lemma MOD_EQ_0: "(n::nat) ~= (0::nat)
+==> ((m::nat) mod n = (0::nat)) = (EX q::nat. m = q * n)"
+  by (import hollight MOD_EQ_0)
+
+lemma EVEN_MOD: "even (n::nat) = (n mod (2::nat) = (0::nat))"
+  by (import hollight EVEN_MOD)
+
+lemma ODD_MOD: "odd (n::nat) = (n mod (2::nat) = (1::nat))"
+  by (import hollight ODD_MOD)
+
+lemma MOD_MULT_RMOD: "(n::nat) ~= (0::nat) ==> (m::nat) * ((p::nat) mod n) mod n = m * p mod n"
+  by (import hollight MOD_MULT_RMOD)
+
+lemma MOD_MULT_LMOD: "(xa::nat) ~= (0::nat) ==> (x::nat) mod xa * (xb::nat) mod xa = x * xb mod xa"
+  by (import hollight MOD_MULT_LMOD)
+
+lemma MOD_MULT_MOD2: "(xa::nat) ~= (0::nat)
+==> (x::nat) mod xa * ((xb::nat) mod xa) mod xa = x * xb mod xa"
+  by (import hollight MOD_MULT_MOD2)
+
+lemma MOD_EXP_MOD: "(n::nat) ~= (0::nat) ==> ((m::nat) mod n) ^ (p::nat) mod n = m ^ p mod n"
+  by (import hollight MOD_EXP_MOD)
+
+lemma MOD_ADD_MOD: "(n::nat) ~= (0::nat)
+==> ((a::nat) mod n + (b::nat) mod n) mod n = (a + b) mod n"
+  by (import hollight MOD_ADD_MOD)
+
+lemma DIV_ADD_MOD: "(n::nat) ~= (0::nat)
+==> (((a::nat) + (b::nat)) mod n = a mod n + b mod n) =
+    ((a + b) div n = a div n + b div n)"
+  by (import hollight DIV_ADD_MOD)
+
+lemma MOD_LE: "(n::nat) ~= (0::nat) ==> (m::nat) mod n <= m"
+  by (import hollight MOD_LE)
+
+lemma DIV_MONO2: "(p::nat) ~= (0::nat) & p <= (m::nat) ==> (n::nat) div m <= n div p"
+  by (import hollight DIV_MONO2)
+
+lemma DIV_LE_EXCLUSION: "(b::nat) ~= (0::nat) & b * (c::nat) < ((a::nat) + (1::nat)) * (d::nat)
+==> c div d <= a div b"
+  by (import hollight DIV_LE_EXCLUSION)
+
+lemma DIV_EQ_EXCLUSION: "(b::nat) * (c::nat) < ((a::nat) + (1::nat)) * (d::nat) &
+a * d < (c + (1::nat)) * b
+==> a div b = c div d"
+  by (import hollight DIV_EQ_EXCLUSION)
+
+lemma MULT_DIV_LE: "(p::nat) ~= (0::nat) ==> (m::nat) * ((n::nat) div p) <= m * n div p"
+  by (import hollight MULT_DIV_LE)
+
+lemma DIV_DIV: "(xa::nat) * (xb::nat) ~= (0::nat)
+==> (x::nat) div xa div xb = x div (xa * xb)"
+  by (import hollight DIV_DIV)
+
+lemma DIV_MOD: "(xa::nat) * (xb::nat) ~= (0::nat)
+==> (x::nat) div xa mod xb = x mod (xa * xb) div xa"
+  by (import hollight DIV_MOD)
+
+lemma PRE_ELIM_THM: "P (n - Suc 0) = (ALL m. n = Suc m | m = 0 & n = 0 --> P m)"
+  by (import hollight PRE_ELIM_THM)
+
+lemma SUB_ELIM_THM: "(P::nat => bool) ((a::nat) - (b::nat)) =
+(ALL d::nat. a = b + d | a < b & d = (0::nat) --> P d)"
+  by (import hollight SUB_ELIM_THM)
+
+lemma DIVMOD_ELIM_THM: "(P::nat => nat => bool) ((m::nat) div (n::nat)) (m mod n) =
+(ALL (x::nat) xa::nat.
+    n = (0::nat) & x = (0::nat) & xa = m | m = x * n + xa & xa < n -->
+    P x xa)"
+  by (import hollight DIVMOD_ELIM_THM)
+
+definition
+  minimal :: "(nat => bool) => nat"  where
+  "minimal == %u. SOME n. u n & (ALL m<n. ~ u m)"
+
+lemma DEF_minimal: "minimal = (%u. SOME n. u n & (ALL m<n. ~ u m))"
+  by (import hollight DEF_minimal)
+
+lemma MINIMAL: "Ex P = (P (minimal P) & (ALL x<minimal P. ~ P x))"
+  by (import hollight MINIMAL)
+
+lemma TRANSITIVE_STEPWISE_LT_EQ: "(!!x y z. R x y & R y z ==> R x z)
+==> (ALL m n. m < n --> R m n) = (ALL n. R n (Suc n))"
+  by (import hollight TRANSITIVE_STEPWISE_LT_EQ)
+
+lemma TRANSITIVE_STEPWISE_LT: "[| (ALL x y z. R x y & R y z --> R x z) & (ALL n. R n (Suc n)); m < n |]
+==> R m n"
+  by (import hollight TRANSITIVE_STEPWISE_LT)
+
+lemma TRANSITIVE_STEPWISE_LE_EQ: "(ALL x. R x x) & (ALL x y z. R x y & R y z --> R x z)
+==> (ALL m n. m <= n --> R m n) = (ALL n. R n (Suc n))"
+  by (import hollight TRANSITIVE_STEPWISE_LE_EQ)
+
+lemma TRANSITIVE_STEPWISE_LE: "[| (ALL x. R x x) &
+   (ALL x y z. R x y & R y z --> R x z) & (ALL n. R n (Suc n));
+   m <= n |]
+==> R m n"
+  by (import hollight TRANSITIVE_STEPWISE_LE)
+
+lemma WF_EQ: "wfP (u_556::'A => 'A => bool) =
+(ALL P::'A => bool.
+    Ex P = (EX x::'A. P x & (ALL y::'A. u_556 y x --> ~ P y)))"
+  by (import hollight WF_EQ)
+
+lemma WF_IND: "wfP (u_556::'A => 'A => bool) =
+(ALL P::'A => bool.
+    (ALL x::'A. (ALL y::'A. u_556 y x --> P y) --> P x) --> All P)"
+  by (import hollight WF_IND)
+
+lemma WF_DCHAIN: "wfP (u_556::'A => 'A => bool) =
+(~ (EX s::nat => 'A. ALL n::nat. u_556 (s (Suc n)) (s n)))"
+  by (import hollight WF_DCHAIN)
+
+lemma WF_UREC: "[| wfP (u_556::'A => 'A => bool);
+   !!(f::'A => 'B) (g::'A => 'B) x::'A.
+      (!!z::'A. u_556 z x ==> f z = g z)
+      ==> (H::('A => 'B) => 'A => 'B) f x = H g x;
+   (ALL x::'A. (f::'A => 'B) x = H f x) &
+   (ALL x::'A. (g::'A => 'B) x = H g x) |]
+==> f = g"
+  by (import hollight WF_UREC)
+
+lemma WF_UREC_WF: "(!!(H::('A => bool) => 'A => bool) (f::'A => bool) g::'A => bool.
+    [| !!(f::'A => bool) (g::'A => bool) x::'A.
+          (!!z::'A. (u_556::'A => 'A => bool) z x ==> f z = g z)
+          ==> H f x = H g x;
+       (ALL x::'A. f x = H f x) & (ALL x::'A. g x = H g x) |]
+    ==> f = g)
+==> wfP u_556"
+  by (import hollight WF_UREC_WF)
+
+lemma WF_REC_INVARIANT: "[| wfP (u_556::'A => 'A => bool);
+   !!(f::'A => 'B) (g::'A => 'B) x::'A.
+      (!!z::'A. u_556 z x ==> f z = g z & (S::'A => 'B => bool) z (f z))
+      ==> (H::('A => 'B) => 'A => 'B) f x = H g x & S x (H f x) |]
+==> EX f::'A => 'B. ALL x::'A. f x = H f x"
+  by (import hollight WF_REC_INVARIANT)
+
+lemma WF_REC: "[| wfP (u_556::'A => 'A => bool);
+   !!(f::'A => 'B) (g::'A => 'B) x::'A.
+      (!!z::'A. u_556 z x ==> f z = g z)
+      ==> (H::('A => 'B) => 'A => 'B) f x = H g x |]
+==> EX f::'A => 'B. ALL x::'A. f x = H f x"
+  by (import hollight WF_REC)
+
+lemma WF_REC_WF: "(!!H::('A => nat) => 'A => nat.
+    (!!(f::'A => nat) (g::'A => nat) x::'A.
+        (!!z::'A. (u_556::'A => 'A => bool) z x ==> f z = g z)
+        ==> H f x = H g x)
+    ==> EX f::'A => nat. ALL x::'A. f x = H f x)
+==> wfP u_556"
+  by (import hollight WF_REC_WF)
+
+lemma WF_EREC: "[| wfP (u_556::'A => 'A => bool);
+   !!(f::'A => 'B) (g::'A => 'B) x::'A.
+      (!!z::'A. u_556 z x ==> f z = g z)
+      ==> (H::('A => 'B) => 'A => 'B) f x = H g x |]
+==> EX! f::'A => 'B. ALL x::'A. f x = H f x"
+  by (import hollight WF_EREC)
+
+lemma WF_SUBSET: "(ALL (x::'A) y::'A.
+    (u_556::'A => 'A => bool) x y --> (u_670::'A => 'A => bool) x y) &
+wfP u_670
+==> wfP u_556"
+  by (import hollight WF_SUBSET)
+
+lemma WF_MEASURE_GEN: "wfP (u_556::'B => 'B => bool)
+==> wfP (%(x::'A) x'::'A. u_556 ((m::'A => 'B) x) (m x'))"
+  by (import hollight WF_MEASURE_GEN)
+
+lemma WF_LEX_DEPENDENT: "wfP (R::'A => 'A => bool) & (ALL x::'A. wfP ((S::'A => 'B => 'B => bool) x))
+==> wfP (SOME f::'A * 'B => 'A * 'B => bool.
+            ALL (r1::'A) s1::'B.
+               f (r1, s1) =
+               (SOME f::'A * 'B => bool.
+                   ALL (r2::'A) s2::'B.
+                      f (r2, s2) = (R r1 r2 | r1 = r2 & S r1 s1 s2)))"
+  by (import hollight WF_LEX_DEPENDENT)
+
+lemma WF_LEX: "wfP (x::'A => 'A => bool) & wfP (xa::'B => 'B => bool)
+==> wfP (SOME f::'A * 'B => 'A * 'B => bool.
+            ALL (r1::'A) s1::'B.
+               f (r1, s1) =
+               (SOME f::'A * 'B => bool.
+                   ALL (r2::'A) s2::'B.
+                      f (r2, s2) = (x r1 r2 | r1 = r2 & xa s1 s2)))"
+  by (import hollight WF_LEX)
+
+lemma WF_POINTWISE: "wfP (u_556::'A => 'A => bool) & wfP (u_670::'B => 'B => bool)
+==> wfP (SOME f::'A * 'B => 'A * 'B => bool.
+            ALL (x1::'A) y1::'B.
+               f (x1, y1) =
+               (SOME f::'A * 'B => bool.
+                   ALL (x2::'A) y2::'B.
+                      f (x2, y2) = (u_556 x1 x2 & u_670 y1 y2)))"
+  by (import hollight WF_POINTWISE)
+
+lemma WF_num: "(wfP::(nat => nat => bool) => bool) (op <::nat => nat => bool)"
+  by (import hollight WF_num)
+
+lemma WF_REC_num: "(!!(f::nat => 'A) (g::nat => 'A) x::nat.
+    (!!z::nat. z < x ==> f z = g z)
+    ==> (H::(nat => 'A) => nat => 'A) f x = H g x)
+==> EX f::nat => 'A. ALL x::nat. f x = H f x"
+  by (import hollight WF_REC_num)
+
+lemma WF_MEASURE: "wfP (%(a::'A) b::'A. (a, b) : measure (m::'A => nat))"
+  by (import hollight WF_MEASURE)
+
+lemma MEASURE_LE: "(ALL x::'q_12099.
+    (x, a::'q_12099) : measure (m::'q_12099 => nat) -->
+    (x, b::'q_12099) : measure m) =
+(m a <= m b)"
+  by (import hollight MEASURE_LE)
+
+lemma WF_REFL: "wfP (u_556::'A => 'A => bool) ==> ~ u_556 (x::'A) x"
+  by (import hollight WF_REFL)
+
+lemma WF_REC_TAIL: "EX f::'A => 'B.
+   ALL x::'A.
+      f x =
+      (if (P::'A => bool) x then f ((g::'A => 'A) x) else (h::'A => 'B) x)"
+  by (import hollight WF_REC_TAIL)
+
+lemma WF_REC_TAIL_GENERAL: "wfP (u_556::'A => 'A => bool) &
+(ALL (f::'A => 'B) (g::'A => 'B) x::'A.
+    (ALL z::'A. u_556 z x --> f z = g z) -->
+    (P::('A => 'B) => 'A => bool) f x = P g x &
+    (G::('A => 'B) => 'A => 'A) f x = G g x &
+    (H::('A => 'B) => 'A => 'B) f x = H g x) &
+(ALL (f::'A => 'B) (g::'A => 'B) x::'A.
+    (ALL z::'A. u_556 z x --> f z = g z) --> H f x = H g x) &
+(ALL (f::'A => 'B) (x::'A) y::'A. P f x & u_556 y (G f x) --> u_556 y x)
+==> EX f::'A => 'B. ALL x::'A. f x = (if P f x then f (G f x) else H f x)"
+  by (import hollight WF_REC_TAIL_GENERAL)
+
+lemma ARITH_ZERO: "(0::nat) = (0::nat) & (0::nat) = (0::nat)"
+  by (import hollight ARITH_ZERO)
+
+lemma ARITH_SUC: "(ALL x. Suc x = Suc x) &
+Suc 0 = 1 &
+(ALL x. Suc (2 * x) = 2 * x + 1) & (ALL x. Suc (2 * x + 1) = 2 * Suc x)"
+  by (import hollight ARITH_SUC)
+
+lemma ARITH_PRE: "(ALL x. x - Suc 0 = x - Suc 0) &
+0 - Suc 0 = 0 &
+(ALL x. 2 * x - Suc 0 = (if x = 0 then 0 else 2 * (x - Suc 0) + 1)) &
+(ALL x. 2 * x + 1 - Suc 0 = 2 * x)"
+  by (import hollight ARITH_PRE)
+
+lemma ARITH_ADD: "(ALL (x::nat) xa::nat. x + xa = x + xa) &
+(0::nat) + (0::nat) = (0::nat) &
+(ALL x::nat. (0::nat) + (2::nat) * x = (2::nat) * x) &
+(ALL x::nat.
+    (0::nat) + ((2::nat) * x + (1::nat)) = (2::nat) * x + (1::nat)) &
+(ALL x::nat. (2::nat) * x + (0::nat) = (2::nat) * x) &
+(ALL x::nat. (2::nat) * x + (1::nat) + (0::nat) = (2::nat) * x + (1::nat)) &
+(ALL (x::nat) xa::nat. (2::nat) * x + (2::nat) * xa = (2::nat) * (x + xa)) &
+(ALL (x::nat) xa::nat.
+    (2::nat) * x + ((2::nat) * xa + (1::nat)) =
+    (2::nat) * (x + xa) + (1::nat)) &
+(ALL (x::nat) xa::nat.
+    (2::nat) * x + (1::nat) + (2::nat) * xa =
+    (2::nat) * (x + xa) + (1::nat)) &
+(ALL (x::nat) xa::nat.
+    (2::nat) * x + (1::nat) + ((2::nat) * xa + (1::nat)) =
+    (2::nat) * Suc (x + xa))"
+  by (import hollight ARITH_ADD)
+
+lemma ARITH_MULT: "(ALL (x::nat) xa::nat. x * xa = x * xa) &
+(0::nat) * (0::nat) = (0::nat) &
+(ALL x::nat. (0::nat) * ((2::nat) * x) = (0::nat)) &
+(ALL x::nat. (0::nat) * ((2::nat) * x + (1::nat)) = (0::nat)) &
+(ALL x::nat. (2::nat) * x * (0::nat) = (0::nat)) &
+(ALL x::nat. ((2::nat) * x + (1::nat)) * (0::nat) = (0::nat)) &
+(ALL (x::nat) xa::nat.
+    (2::nat) * x * ((2::nat) * xa) = (2::nat) * ((2::nat) * (x * xa))) &
+(ALL (x::nat) xa::nat.
+    (2::nat) * x * ((2::nat) * xa + (1::nat)) =
+    (2::nat) * x + (2::nat) * ((2::nat) * (x * xa))) &
+(ALL (x::nat) xa::nat.
+    ((2::nat) * x + (1::nat)) * ((2::nat) * xa) =
+    (2::nat) * xa + (2::nat) * ((2::nat) * (x * xa))) &
+(ALL (x::nat) xa::nat.
+    ((2::nat) * x + (1::nat)) * ((2::nat) * xa + (1::nat)) =
+    (2::nat) * x + (1::nat) +
+    ((2::nat) * xa + (2::nat) * ((2::nat) * (x * xa))))"
+  by (import hollight ARITH_MULT)
+
+lemma ARITH_EXP: "(ALL (x::nat) xa::nat. x ^ xa = x ^ xa) &
+(0::nat) ^ (0::nat) = (1::nat) &
+(ALL m::nat. ((2::nat) * m) ^ (0::nat) = (1::nat)) &
+(ALL m::nat. ((2::nat) * m + (1::nat)) ^ (0::nat) = (1::nat)) &
+(ALL n::nat. (0::nat) ^ ((2::nat) * n) = (0::nat) ^ n * (0::nat) ^ n) &
+(ALL (m::nat) n::nat.
+    ((2::nat) * m) ^ ((2::nat) * n) =
+    ((2::nat) * m) ^ n * ((2::nat) * m) ^ n) &
+(ALL (m::nat) n::nat.
+    ((2::nat) * m + (1::nat)) ^ ((2::nat) * n) =
+    ((2::nat) * m + (1::nat)) ^ n * ((2::nat) * m + (1::nat)) ^ n) &
+(ALL n::nat. (0::nat) ^ ((2::nat) * n + (1::nat)) = (0::nat)) &
+(ALL (m::nat) n::nat.
+    ((2::nat) * m) ^ ((2::nat) * n + (1::nat)) =
+    (2::nat) * m * (((2::nat) * m) ^ n * ((2::nat) * m) ^ n)) &
+(ALL (m::nat) n::nat.
+    ((2::nat) * m + (1::nat)) ^ ((2::nat) * n + (1::nat)) =
+    ((2::nat) * m + (1::nat)) *
+    (((2::nat) * m + (1::nat)) ^ n * ((2::nat) * m + (1::nat)) ^ n))"
+  by (import hollight ARITH_EXP)
+
+lemma ARITH_EVEN: "(ALL x::nat. even x = even x) &
+even (0::nat) = True &
+(ALL x::nat. even ((2::nat) * x) = True) &
+(ALL x::nat. even ((2::nat) * x + (1::nat)) = False)"
+  by (import hollight ARITH_EVEN)
+
+lemma ARITH_ODD: "(ALL x::nat. odd x = odd x) &
+odd (0::nat) = False &
+(ALL x::nat. odd ((2::nat) * x) = False) &
+(ALL x::nat. odd ((2::nat) * x + (1::nat)) = True)"
+  by (import hollight ARITH_ODD)
+
+lemma ARITH_LE: "(ALL (x::nat) xa::nat. (x <= xa) = (x <= xa)) &
+((0::nat) <= (0::nat)) = True &
+(ALL x::nat. ((2::nat) * x <= (0::nat)) = (x <= (0::nat))) &
+(ALL x::nat. ((2::nat) * x + (1::nat) <= (0::nat)) = False) &
+(ALL x::nat. ((0::nat) <= (2::nat) * x) = True) &
+(ALL x::nat. ((0::nat) <= (2::nat) * x + (1::nat)) = True) &
+(ALL (x::nat) xa::nat. ((2::nat) * x <= (2::nat) * xa) = (x <= xa)) &
+(ALL (x::nat) xa::nat.
+    ((2::nat) * x <= (2::nat) * xa + (1::nat)) = (x <= xa)) &
+(ALL (x::nat) xa::nat.
+    ((2::nat) * x + (1::nat) <= (2::nat) * xa) = (x < xa)) &
+(ALL (x::nat) xa::nat.
+    ((2::nat) * x + (1::nat) <= (2::nat) * xa + (1::nat)) = (x <= xa))"
+  by (import hollight ARITH_LE)
+
+lemma ARITH_LT: "(ALL (x::nat) xa::nat. (x < xa) = (x < xa)) &
+((0::nat) < (0::nat)) = False &
+(ALL x::nat. ((2::nat) * x < (0::nat)) = False) &
+(ALL x::nat. ((2::nat) * x + (1::nat) < (0::nat)) = False) &
+(ALL x::nat. ((0::nat) < (2::nat) * x) = ((0::nat) < x)) &
+(ALL x::nat. ((0::nat) < (2::nat) * x + (1::nat)) = True) &
+(ALL (x::nat) xa::nat. ((2::nat) * x < (2::nat) * xa) = (x < xa)) &
+(ALL (x::nat) xa::nat.
+    ((2::nat) * x < (2::nat) * xa + (1::nat)) = (x <= xa)) &
+(ALL (x::nat) xa::nat.
+    ((2::nat) * x + (1::nat) < (2::nat) * xa) = (x < xa)) &
+(ALL (x::nat) xa::nat.
+    ((2::nat) * x + (1::nat) < (2::nat) * xa + (1::nat)) = (x < xa))"
+  by (import hollight ARITH_LT)
+
+lemma ARITH_EQ: "(ALL (x::nat) xa::nat. (x = xa) = (x = xa)) &
+((0::nat) = (0::nat)) = True &
+(ALL x::nat. ((2::nat) * x = (0::nat)) = (x = (0::nat))) &
+(ALL x::nat. ((2::nat) * x + (1::nat) = (0::nat)) = False) &
+(ALL x::nat. ((0::nat) = (2::nat) * x) = ((0::nat) = x)) &
+(ALL x::nat. ((0::nat) = (2::nat) * x + (1::nat)) = False) &
+(ALL (x::nat) xa::nat. ((2::nat) * x = (2::nat) * xa) = (x = xa)) &
+(ALL (x::nat) xa::nat. ((2::nat) * x = (2::nat) * xa + (1::nat)) = False) &
+(ALL (x::nat) xa::nat. ((2::nat) * x + (1::nat) = (2::nat) * xa) = False) &
+(ALL (x::nat) xa::nat.
+    ((2::nat) * x + (1::nat) = (2::nat) * xa + (1::nat)) = (x = xa))"
+  by (import hollight ARITH_EQ)
+
+lemma ARITH_SUB: "(ALL (x::nat) xa::nat. x - xa = x - xa) &
+(0::nat) - (0::nat) = (0::nat) &
+(ALL x::nat. (0::nat) - (2::nat) * x = (0::nat)) &
+(ALL x::nat. (0::nat) - ((2::nat) * x + (1::nat)) = (0::nat)) &
+(ALL x::nat. (2::nat) * x - (0::nat) = (2::nat) * x) &
+(ALL x::nat. (2::nat) * x + (1::nat) - (0::nat) = (2::nat) * x + (1::nat)) &
+(ALL (m::nat) n::nat. (2::nat) * m - (2::nat) * n = (2::nat) * (m - n)) &
+(ALL (m::nat) n::nat.
+    (2::nat) * m - ((2::nat) * n + (1::nat)) =
+    (2::nat) * (m - n) - Suc (0::nat)) &
+(ALL (m::nat) n::nat.
+    (2::nat) * m + (1::nat) - (2::nat) * n =
+    (if n <= m then (2::nat) * (m - n) + (1::nat) else (0::nat))) &
+(ALL (m::nat) n::nat.
+    (2::nat) * m + (1::nat) - ((2::nat) * n + (1::nat)) =
+    (2::nat) * (m - n))"
+  by (import hollight ARITH_SUB)
+
+lemma right_th: "(s::nat) * ((2::nat) * (x::nat) + (1::nat)) = s + (2::nat) * (s * x)"
+  by (import hollight right_th)
+
+lemma SEMIRING_PTHS: "(ALL (x::'A) (y::'A) z::'A.
+    (add::'A => 'A => 'A) x (add y z) = add (add x y) z) &
+(ALL (x::'A) y::'A. add x y = add y x) &
+(ALL x::'A. add (r0::'A) x = x) &
+(ALL (x::'A) (y::'A) z::'A.
+    (mul::'A => 'A => 'A) x (mul y z) = mul (mul x y) z) &
+(ALL (x::'A) y::'A. mul x y = mul y x) &
+(ALL x::'A. mul (r1::'A) x = x) &
+(ALL x::'A. mul r0 x = r0) &
+(ALL (x::'A) (y::'A) z::'A. mul x (add y z) = add (mul x y) (mul x z)) &
+(ALL x::'A. (pwr::'A => nat => 'A) x (0::nat) = r1) &
+(ALL (x::'A) n::nat. pwr x (Suc n) = mul x (pwr x n))
+==> mul r1 (x::'A) = x &
+    add (mul (a::'A) (m::'A)) (mul (b::'A) m) = mul (add a b) m &
+    add (mul a m) m = mul (add a r1) m &
+    add m (mul a m) = mul (add a r1) m &
+    add m m = mul (add r1 r1) m &
+    mul r0 m = r0 &
+    add r0 a = a &
+    add a r0 = a &
+    mul a b = mul b a &
+    mul (add a b) (c::'A) = add (mul a c) (mul b c) &
+    mul r0 a = r0 &
+    mul a r0 = r0 &
+    mul r1 a = a &
+    mul a r1 = a &
+    mul (mul (lx::'A) (ly::'A)) (mul (rx::'A) (ry::'A)) =
+    mul (mul lx rx) (mul ly ry) &
+    mul (mul lx ly) (mul rx ry) = mul lx (mul ly (mul rx ry)) &
+    mul (mul lx ly) (mul rx ry) = mul rx (mul (mul lx ly) ry) &
+    mul (mul lx ly) rx = mul (mul lx rx) ly &
+    mul (mul lx ly) rx = mul lx (mul ly rx) &
+    mul lx rx = mul rx lx &
+    mul lx (mul rx ry) = mul (mul lx rx) ry &
+    mul lx (mul rx ry) = mul rx (mul lx ry) &
+    add (add a b) (add c (d::'A)) = add (add a c) (add b d) &
+    add (add a b) c = add a (add b c) &
+    add a (add c d) = add c (add a d) &
+    add (add a b) c = add (add a c) b &
+    add a c = add c a &
+    add a (add c d) = add (add a c) d &
+    mul (pwr x (p::nat)) (pwr x (q::nat)) = pwr x (p + q) &
+    mul x (pwr x q) = pwr x (Suc q) &
+    mul (pwr x q) x = pwr x (Suc q) &
+    mul x x = pwr x (2::nat) &
+    pwr (mul x (y::'A)) q = mul (pwr x q) (pwr y q) &
+    pwr (pwr x p) q = pwr x (p * q) &
+    pwr x (0::nat) = r1 &
+    pwr x (1::nat) = x &
+    mul x (add y (z::'A)) = add (mul x y) (mul x z) &
+    pwr x (Suc q) = mul x (pwr x q)"
+  by (import hollight SEMIRING_PTHS)
+
+lemma NUM_INTEGRAL_LEMMA: "(w::nat) = (x::nat) + (d::nat) & (y::nat) = (z::nat) + (e::nat)
+==> (w * y + x * z = w * z + x * y) = (w = x | y = z)"
+  by (import hollight NUM_INTEGRAL_LEMMA)
+
+lemma NUM_INTEGRAL: "(ALL x::nat. (0::nat) * x = (0::nat)) &
+(ALL (x::nat) (xa::nat) xb::nat. (x + xa = x + xb) = (xa = xb)) &
+(ALL (w::nat) (x::nat) (y::nat) z::nat.
+    (w * y + x * z = w * z + x * y) = (w = x | y = z))"
+  by (import hollight NUM_INTEGRAL)
+
+lemma INJ_INVERSE2: "(!!(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"
+  by (import hollight INJ_INVERSE2)
+
+definition
+  NUMPAIR :: "nat => nat => nat"  where
+  "NUMPAIR == %u ua. 2 ^ u * (2 * ua + 1)"
+
+lemma DEF_NUMPAIR: "NUMPAIR = (%u ua. 2 ^ u * (2 * ua + 1))"
+  by (import hollight DEF_NUMPAIR)
+
+lemma NUMPAIR_INJ_LEMMA: "NUMPAIR x xa = NUMPAIR xb xc ==> x = xb"
+  by (import hollight NUMPAIR_INJ_LEMMA)
+
+lemma NUMPAIR_INJ: "(NUMPAIR x1 y1 = NUMPAIR x2 y2) = (x1 = x2 & y1 = y2)"
+  by (import hollight NUMPAIR_INJ)
+
+definition
+  NUMFST :: "nat => nat"  where
+  "NUMFST == SOME X. EX Y. ALL x y. X (NUMPAIR x y) = x & Y (NUMPAIR x y) = y"
+
+lemma DEF_NUMFST: "NUMFST = (SOME X. EX Y. ALL x y. X (NUMPAIR x y) = x & Y (NUMPAIR x y) = y)"
+  by (import hollight DEF_NUMFST)
+
+definition
+  NUMSND :: "nat => nat"  where
+  "NUMSND == SOME Y. ALL x y. NUMFST (NUMPAIR x y) = x & Y (NUMPAIR x y) = y"
+
+lemma DEF_NUMSND: "NUMSND = (SOME Y. ALL x y. NUMFST (NUMPAIR x y) = x & Y (NUMPAIR x y) = y)"
+  by (import hollight DEF_NUMSND)
+
+definition
+  NUMSUM :: "bool => nat => nat"  where
+  "NUMSUM == %u ua. if u then Suc (2 * ua) else 2 * ua"
+
+lemma DEF_NUMSUM: "NUMSUM = (%u ua. if u then Suc (2 * ua) else 2 * ua)"
+  by (import hollight DEF_NUMSUM)
+
+lemma NUMSUM_INJ: "(NUMSUM b1 x1 = NUMSUM b2 x2) = (b1 = b2 & x1 = x2)"
+  by (import hollight NUMSUM_INJ)
+
+definition
+  NUMLEFT :: "nat => bool"  where
+  "NUMLEFT == SOME X. EX Y. ALL x y. X (NUMSUM x y) = x & Y (NUMSUM x y) = y"
+
+lemma DEF_NUMLEFT: "NUMLEFT = (SOME X. EX Y. ALL x y. X (NUMSUM x y) = x & Y (NUMSUM x y) = y)"
+  by (import hollight DEF_NUMLEFT)
+
+definition
+  NUMRIGHT :: "nat => nat"  where
+  "NUMRIGHT == SOME Y. ALL x y. NUMLEFT (NUMSUM x y) = x & Y (NUMSUM x y) = y"
+
+lemma DEF_NUMRIGHT: "NUMRIGHT = (SOME Y. ALL x y. NUMLEFT (NUMSUM x y) = x & Y (NUMSUM x y) = y)"
+  by (import hollight DEF_NUMRIGHT)
+
+definition
+  INJN :: "nat => nat => 'A => bool"  where
+  "INJN == %(u::nat) (n::nat) a::'A. n = u"
+
+lemma DEF_INJN: "INJN = (%(u::nat) (n::nat) a::'A. n = u)"
+  by (import hollight DEF_INJN)
+
+lemma INJN_INJ: "(op =::bool => bool => bool)
+ ((op =::(nat => 'A::type => bool) => (nat => 'A::type => bool) => bool)
+   ((INJN::nat => nat => 'A::type => bool) (n1::nat))
+   ((INJN::nat => nat => 'A::type => bool) (n2::nat)))
+ ((op =::nat => nat => bool) n1 n2)"
+  by (import hollight INJN_INJ)
+
+definition
+  INJA :: "'A => nat => 'A => bool"  where
+  "INJA == %(u::'A) (n::nat) b::'A. b = u"
+
+lemma DEF_INJA: "INJA = (%(u::'A) (n::nat) b::'A. b = u)"
+  by (import hollight DEF_INJA)
+
+lemma INJA_INJ: "(INJA (a1::'A) = INJA (a2::'A)) = (a1 = a2)"
+  by (import hollight INJA_INJ)
+
+definition
+  INJF :: "(nat => nat => 'A => bool) => nat => 'A => bool"  where
+  "INJF == %(u::nat => nat => 'A => bool) n::nat. u (NUMFST n) (NUMSND n)"
+
+lemma DEF_INJF: "INJF = (%(u::nat => nat => 'A => bool) n::nat. u (NUMFST n) (NUMSND n))"
+  by (import hollight DEF_INJF)
+
+lemma INJF_INJ: "(INJF (f1::nat => nat => 'A => bool) =
+ INJF (f2::nat => nat => 'A => bool)) =
+(f1 = f2)"
+  by (import hollight INJF_INJ)
+
+definition
+  INJP :: "(nat => 'A => bool) => (nat => 'A => bool) => nat => 'A => bool"  where
+  "INJP ==
+%(u::nat => 'A => bool) (ua::nat => 'A => bool) (n::nat) a::'A.
+   if NUMLEFT n then u (NUMRIGHT n) a else ua (NUMRIGHT n) a"
+
+lemma DEF_INJP: "INJP =
+(%(u::nat => 'A => bool) (ua::nat => 'A => bool) (n::nat) a::'A.
+    if NUMLEFT n then u (NUMRIGHT n) a else ua (NUMRIGHT n) a)"
+  by (import hollight DEF_INJP)
+
+lemma INJP_INJ: "(INJP (f1::nat => 'A => bool) (f2::nat => 'A => bool) =
+ INJP (f1'::nat => 'A => bool) (f2'::nat => 'A => bool)) =
+(f1 = f1' & f2 = f2')"
+  by (import hollight INJP_INJ)
+
+definition
+  ZCONSTR :: "nat => 'A => (nat => nat => 'A => bool) => nat => 'A => bool"  where
+  "ZCONSTR ==
+%(u::nat) (ua::'A) ub::nat => nat => 'A => bool.
+   INJP (INJN (Suc u)) (INJP (INJA ua) (INJF ub))"
+
+lemma DEF_ZCONSTR: "ZCONSTR =
+(%(u::nat) (ua::'A) ub::nat => nat => 'A => bool.
+    INJP (INJN (Suc u)) (INJP (INJA ua) (INJF ub)))"
+  by (import hollight DEF_ZCONSTR)
+
+definition
+  ZBOT :: "nat => 'A => bool"  where
+  "ZBOT == INJP (INJN (0::nat)) (SOME z::nat => 'A => bool. True)"
+
+lemma DEF_ZBOT: "ZBOT = INJP (INJN (0::nat)) (SOME z::nat => 'A => bool. True)"
+  by (import hollight DEF_ZBOT)
+
+lemma ZCONSTR_ZBOT: "ZCONSTR (x::nat) (xa::'A) (xb::nat => nat => 'A => bool) ~= ZBOT"
+  by (import hollight ZCONSTR_ZBOT)
+
+definition
+  ZRECSPACE :: "(nat => 'A => bool) => bool"  where
+  "ZRECSPACE ==
+%a::nat => 'A => bool.
+   ALL ZRECSPACE'::(nat => 'A => bool) => bool.
+      (ALL a::nat => 'A => bool.
+          a = ZBOT |
+          (EX (c::nat) (i::'A) r::nat => nat => 'A => bool.
+              a = ZCONSTR c i r & (ALL n::nat. ZRECSPACE' (r n))) -->
+          ZRECSPACE' a) -->
+      ZRECSPACE' a"
+
+lemma DEF_ZRECSPACE: "ZRECSPACE =
+(%a::nat => 'A => bool.
+    ALL ZRECSPACE'::(nat => 'A => bool) => bool.
+       (ALL a::nat => 'A => bool.
+           a = ZBOT |
+           (EX (c::nat) (i::'A) r::nat => nat => 'A => bool.
+               a = ZCONSTR c i r & (ALL n::nat. ZRECSPACE' (r n))) -->
+           ZRECSPACE' a) -->
+       ZRECSPACE' a)"
+  by (import hollight DEF_ZRECSPACE)
+
+typedef (open) 'a recspace = "Collect ZRECSPACE :: (nat \<Rightarrow> 'a \<Rightarrow> bool) set" 
+  morphisms "_dest_rec" "_mk_rec"
+  apply (rule light_ex_imp_nonempty [where t="ZBOT"])
+  by (import hollight TYDEF_recspace)
+
+syntax
+  "_dest_rec" :: _ ("'_dest'_rec")
+
+syntax
+  "_mk_rec" :: _ ("'_mk'_rec")
+
+lemmas "TYDEF_recspace_@intern" = typedef_hol2hollight 
+  [where a="a :: 'A recspace" and r=r ,
+   OF type_definition_recspace]
+
+definition
+  BOTTOM :: "'A recspace"  where
+  "BOTTOM == _mk_rec ZBOT"
+
+lemma DEF_BOTTOM: "BOTTOM = _mk_rec ZBOT"
+  by (import hollight DEF_BOTTOM)
+
+definition
+  CONSTR :: "nat => 'A => (nat => 'A recspace) => 'A recspace"  where
+  "CONSTR ==
+%(u::nat) (ua::'A::type) ub::nat => 'A::type recspace.
+   _mk_rec (ZCONSTR u ua (%n::nat. _dest_rec (ub n)))"
+
+lemma DEF_CONSTR: "CONSTR =
+(%(u::nat) (ua::'A::type) ub::nat => 'A::type recspace.
+    _mk_rec (ZCONSTR u ua (%n::nat. _dest_rec (ub n))))"
+  by (import hollight DEF_CONSTR)
+
+lemma MK_REC_INJ: "[| _mk_rec (x::nat => 'A::type => bool) =
+   _mk_rec (y::nat => 'A::type => bool);
+   ZRECSPACE x & ZRECSPACE y |]
+==> x = y"
+  by (import hollight MK_REC_INJ)
+
+lemma CONSTR_BOT: "CONSTR (c::nat) (i::'A) (r::nat => 'A recspace) ~= BOTTOM"
+  by (import hollight CONSTR_BOT)
+
+lemma CONSTR_INJ: "(CONSTR (c1::nat) (i1::'A) (r1::nat => 'A recspace) =
+ CONSTR (c2::nat) (i2::'A) (r2::nat => 'A recspace)) =
+(c1 = c2 & i1 = i2 & r1 = r2)"
+  by (import hollight CONSTR_INJ)
+
+lemma CONSTR_IND: "(P::'A recspace => bool) BOTTOM &
+(ALL (c::nat) (i::'A) r::nat => 'A recspace.
+    (ALL n::nat. P (r n)) --> P (CONSTR c i r))
+==> P (x::'A recspace)"
+  by (import hollight CONSTR_IND)
+
+lemma CONSTR_REC: "EX f::'A recspace => 'B.
+   ALL (c::nat) (i::'A) r::nat => 'A recspace.
+      f (CONSTR c i r) =
+      (Fn::nat => 'A => (nat => 'A recspace) => (nat => 'B) => 'B) c i r
+       (%n::nat. f (r n))"
+  by (import hollight CONSTR_REC)
+
+definition
+  FCONS :: "'A => (nat => 'A) => nat => 'A"  where
+  "FCONS ==
+SOME FCONS::'A => (nat => 'A) => nat => 'A.
+   (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)"
+
+lemma DEF_FCONS: "FCONS =
+(SOME FCONS::'A => (nat => 'A) => nat => 'A.
+    (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))"
+  by (import hollight DEF_FCONS)
+
+lemma FCONS_UNDO: "(f::nat => 'A) = FCONS (f (0::nat)) (f o Suc)"
+  by (import hollight FCONS_UNDO)
+
+definition
+  FNIL :: "nat => 'A"  where
+  "FNIL == %u::nat. SOME x::'A. True"
+
+lemma DEF_FNIL: "FNIL = (%u::nat. SOME x::'A. True)"
+  by (import hollight DEF_FNIL)
+
+definition
+  ISO :: "('A => 'B) => ('B => 'A) => bool"  where
+  "ISO ==
+%(u::'A => 'B) ua::'B => 'A.
+   (ALL x::'B. u (ua x) = x) & (ALL y::'A. ua (u y) = y)"
+
+lemma DEF_ISO: "ISO =
+(%(u::'A => 'B) ua::'B => 'A.
+    (ALL x::'B. u (ua x) = x) & (ALL y::'A. ua (u y) = y))"
+  by (import hollight DEF_ISO)
+
+lemma ISO_REFL: "ISO (%x::'A. x) (%x::'A. x)"
+  by (import hollight ISO_REFL)
+
+lemma ISO_FUN: "ISO (f::'A => 'A') (f'::'A' => 'A) & ISO (g::'B => 'B') (g'::'B' => 'B)
+==> ISO (%(h::'A => 'B) a'::'A'. g (h (f' a')))
+     (%(h::'A' => 'B') a::'A. g' (h (f a)))"
+  by (import hollight ISO_FUN)
+
+lemma ISO_USAGE: "ISO (f::'q_17485 => 'q_17482) (g::'q_17482 => 'q_17485)
+==> (ALL P::'q_17485 => bool. All P = (ALL x::'q_17482. P (g x))) &
+    (ALL P::'q_17485 => bool. Ex P = (EX x::'q_17482. P (g x))) &
+    (ALL (a::'q_17485) b::'q_17482. (a = g b) = (f a = b))"
+  by (import hollight ISO_USAGE)
+
+typedef (open) char = "{a. ALL char'.
+       (ALL a.
+           (EX a0 a1 a2 a3 a4 a5 a6 a7.
+               a =
+               CONSTR (NUMERAL 0) (a0 :: bool, a1 :: bool, a2 :: bool, a3 :: bool, a4 :: bool, a5 :: bool, a6 :: bool, a7:: bool)
+                (%n. BOTTOM)) -->
+           char' a) -->
+       char' a}"
+  morphisms "_dest_char" "_mk_char"
+  apply (rule light_ex_imp_nonempty [where t="CONSTR (NUMERAL 0) (a0, a1, a2, a3, a4, a5, a6, a7) (%n. BOTTOM)"])
+  by (import hollight TYDEF_char)
+
+syntax
+  "_dest_char" :: _ ("'_dest'_char")
+
+syntax
+  "_mk_char" :: _ ("'_mk'_char")
+
+lemmas "TYDEF_char_@intern" = typedef_hol2hollight 
+  [where a="a :: hollight.char" and r=r ,
+   OF type_definition_char]
+
+consts
+  "_11937" :: "bool
+=> bool => bool => bool => bool => bool => bool => bool => hollight.char" ("'_11937")
+
+defs
+  "_11937_def": "_11937 ==
+%(a0::bool) (a1::bool) (a2::bool) (a3::bool) (a4::bool) (a5::bool)
+   (a6::bool) a7::bool.
+   _mk_char
+    (CONSTR (0::nat) (a0, a1, a2, a3, a4, a5, a6, a7) (%n::nat. BOTTOM))"
+
+lemma DEF__11937: "_11937 =
+(%(a0::bool) (a1::bool) (a2::bool) (a3::bool) (a4::bool) (a5::bool)
+    (a6::bool) a7::bool.
+    _mk_char
+     (CONSTR (0::nat) (a0, a1, a2, a3, a4, a5, a6, a7) (%n::nat. BOTTOM)))"
+  by (import hollight DEF__11937)
+
+definition
+  ASCII :: "bool
+=> bool => bool => bool => bool => bool => bool => bool => hollight.char"  where
+  "ASCII == _11937"
+
+lemma DEF_ASCII: "ASCII = _11937"
+  by (import hollight DEF_ASCII)
+
+consts
+  dist :: "nat * nat => nat" 
+
+defs
+  dist_def: "hollight.dist == %u. fst u - snd u + (snd u - fst u)"
+
+lemma DEF_dist: "hollight.dist = (%u. fst u - snd u + (snd u - fst u))"
+  by (import hollight DEF_dist)
+
+lemma DIST_REFL: "hollight.dist (x, x) = 0"
+  by (import hollight DIST_REFL)
+
+lemma DIST_LZERO: "hollight.dist (0, x) = x"
+  by (import hollight DIST_LZERO)
+
+lemma DIST_RZERO: "hollight.dist (x, 0) = x"
+  by (import hollight DIST_RZERO)
+
+lemma DIST_SYM: "hollight.dist (x, xa) = hollight.dist (xa, x)"
+  by (import hollight DIST_SYM)
+
+lemma DIST_LADD: "hollight.dist (x + xb, x + xa) = hollight.dist (xb, xa)"
+  by (import hollight DIST_LADD)
+
+lemma DIST_RADD: "hollight.dist (x + xa, xb + xa) = hollight.dist (x, xb)"
+  by (import hollight DIST_RADD)
+
+lemma DIST_LADD_0: "hollight.dist (x + xa, x) = xa"
+  by (import hollight DIST_LADD_0)
+
+lemma DIST_RADD_0: "hollight.dist (x, x + xa) = xa"
+  by (import hollight DIST_RADD_0)
+
+lemma DIST_LMUL: "x * hollight.dist (xa, xb) = hollight.dist (x * xa, x * xb)"
+  by (import hollight DIST_LMUL)
+
+lemma DIST_RMUL: "hollight.dist (x, xa) * xb = hollight.dist (x * xb, xa * xb)"
+  by (import hollight DIST_RMUL)
+
+lemma DIST_EQ_0: "(hollight.dist (x, xa) = 0) = (x = xa)"
+  by (import hollight DIST_EQ_0)
+
+lemma DIST_ELIM_THM: "P (hollight.dist (x, y)) =
+(ALL d. (x = y + d --> P d) & (y = x + d --> P d))"
+  by (import hollight DIST_ELIM_THM)
+
+lemma DIST_LE_CASES: "(hollight.dist (m, n) <= p) = (m <= n + p & n <= m + p)"
+  by (import hollight DIST_LE_CASES)
+
+lemma DIST_TRIANGLE_LE: "hollight.dist (m, n) + hollight.dist (n, p) <= q
+==> hollight.dist (m, p) <= q"
+  by (import hollight DIST_TRIANGLE_LE)
+
+lemma DIST_TRIANGLES_LE: "hollight.dist (m, n) <= r & hollight.dist (p, q) <= s
+==> hollight.dist (m, p) <= hollight.dist (n, q) + (r + s)"
+  by (import hollight DIST_TRIANGLES_LE)
+
+lemma BOUNDS_LINEAR: "(ALL n::nat. (A::nat) * n <= (B::nat) * n + (C::nat)) = (A <= B)"
+  by (import hollight BOUNDS_LINEAR)
+
+lemma BOUNDS_LINEAR_0: "(ALL n::nat. (A::nat) * n <= (B::nat)) = (A = (0::nat))"
+  by (import hollight BOUNDS_LINEAR_0)
+
+lemma BOUNDS_DIVIDED: "(EX B::nat. ALL n::nat. (P::nat => nat) n <= B) =
+(EX (x::nat) B::nat. ALL n::nat. n * P n <= x * n + B)"
+  by (import hollight BOUNDS_DIVIDED)
+
+lemma BOUNDS_NOTZERO: "(P::nat => nat => nat) (0::nat) (0::nat) = (0::nat) &
+(ALL (m::nat) n::nat. P m n <= (A::nat) * (m + n) + (B::nat))
+==> EX x::nat. ALL (m::nat) n::nat. P m n <= x * (m + n)"
+  by (import hollight BOUNDS_NOTZERO)
+
+lemma BOUNDS_IGNORE: "(EX B::nat. ALL i::nat. (P::nat => nat) i <= (Q::nat => nat) i + B) =
+(EX (x::nat) N::nat. ALL i>=N. P i <= Q i + x)"
+  by (import hollight BOUNDS_IGNORE)
+
+definition
+  is_nadd :: "(nat => nat) => bool"  where
+  "is_nadd ==
+%u. EX B. ALL m n. hollight.dist (m * u n, n * u m) <= B * (m + n)"
+
+lemma DEF_is_nadd: "is_nadd =
+(%u. EX B. ALL m n. hollight.dist (m * u n, n * u m) <= B * (m + n))"
+  by (import hollight DEF_is_nadd)
+
+lemma is_nadd_0: "is_nadd (%n. 0)"
+  by (import hollight is_nadd_0)
+
+typedef (open) nadd = "Collect is_nadd"  morphisms "dest_nadd" "mk_nadd"
+  apply (rule light_ex_imp_nonempty[where t="%n. NUMERAL 0"])
+  by (import hollight TYDEF_nadd)
+
+syntax
+  dest_nadd :: _ 
+
+syntax
+  mk_nadd :: _ 
+
+lemmas "TYDEF_nadd_@intern" = typedef_hol2hollight 
+  [where a="a :: nadd" and r=r ,
+   OF type_definition_nadd]
+
+lemma NADD_CAUCHY: "EX xa.
+   ALL xb xc.
+      hollight.dist (xb * dest_nadd x xc, xc * dest_nadd x xb)
+      <= xa * (xb + xc)"
+  by (import hollight NADD_CAUCHY)
+
+lemma NADD_BOUND: "EX xa B. ALL n. dest_nadd x n <= xa * n + B"
+  by (import hollight NADD_BOUND)
+
+lemma NADD_MULTIPLICATIVE: "EX xa.
+   ALL m n.
+      hollight.dist (dest_nadd x (m * n), m * dest_nadd x n) <= xa * m + xa"
+  by (import hollight NADD_MULTIPLICATIVE)
+
+lemma NADD_ADDITIVE: "EX xa.
+   ALL m n.
+      hollight.dist (dest_nadd x (m + n), dest_nadd x m + dest_nadd x n)
+      <= xa"
+  by (import hollight NADD_ADDITIVE)
+
+lemma NADD_SUC: "EX xa. ALL n. hollight.dist (dest_nadd x (Suc n), dest_nadd x n) <= xa"
+  by (import hollight NADD_SUC)
+
+lemma NADD_DIST_LEMMA: "EX xa. ALL m n. hollight.dist (dest_nadd x (m + n), dest_nadd x m) <= xa * n"
+  by (import hollight NADD_DIST_LEMMA)
+
+lemma NADD_DIST: "EX xa.
+   ALL m n.
+      hollight.dist (dest_nadd x m, dest_nadd x n)
+      <= xa * hollight.dist (m, n)"
+  by (import hollight NADD_DIST)
+
+lemma NADD_ALTMUL: "EX A B.
+   ALL n.
+      hollight.dist
+       (n * dest_nadd x (dest_nadd y n), dest_nadd x n * dest_nadd y n)
+      <= A * n + B"
+  by (import hollight NADD_ALTMUL)
+
+definition
+  nadd_eq :: "nadd => nadd => bool"  where
+  "nadd_eq ==
+%u ua. EX B. ALL n. hollight.dist (dest_nadd u n, dest_nadd ua n) <= B"
+
+lemma DEF_nadd_eq: "nadd_eq =
+(%u ua. EX B. ALL n. hollight.dist (dest_nadd u n, dest_nadd ua n) <= B)"
+  by (import hollight DEF_nadd_eq)
+
+lemma NADD_EQ_REFL: "nadd_eq x x"
+  by (import hollight NADD_EQ_REFL)
+
+lemma NADD_EQ_SYM: "nadd_eq x y = nadd_eq y x"
+  by (import hollight NADD_EQ_SYM)
+
+lemma NADD_EQ_TRANS: "nadd_eq x y & nadd_eq y z ==> nadd_eq x z"
+  by (import hollight NADD_EQ_TRANS)
+
+definition
+  nadd_of_num :: "nat => nadd"  where
+  "nadd_of_num == %u. mk_nadd (op * u)"
+
+lemma DEF_nadd_of_num: "nadd_of_num = (%u. mk_nadd (op * u))"
+  by (import hollight DEF_nadd_of_num)
+
+lemma NADD_OF_NUM: "dest_nadd (nadd_of_num x) = op * x"
+  by (import hollight NADD_OF_NUM)
+
+lemma NADD_OF_NUM_WELLDEF: "m = n ==> nadd_eq (nadd_of_num m) (nadd_of_num n)"
+  by (import hollight NADD_OF_NUM_WELLDEF)
+
+lemma NADD_OF_NUM_EQ: "nadd_eq (nadd_of_num m) (nadd_of_num n) = (m = n)"
+  by (import hollight NADD_OF_NUM_EQ)
+
+definition
+  nadd_le :: "nadd => nadd => bool"  where
+  "nadd_le == %u ua. EX B. ALL n. dest_nadd u n <= dest_nadd ua n + B"
+
+lemma DEF_nadd_le: "nadd_le = (%u ua. EX B. ALL n. dest_nadd u n <= dest_nadd ua n + B)"
+  by (import hollight DEF_nadd_le)
+
+lemma NADD_LE_WELLDEF_LEMMA: "nadd_eq x x' & nadd_eq y y' & nadd_le x y ==> nadd_le x' y'"
+  by (import hollight NADD_LE_WELLDEF_LEMMA)
+
+lemma NADD_LE_WELLDEF: "nadd_eq x x' & nadd_eq y y' ==> nadd_le x y = nadd_le x' y'"
+  by (import hollight NADD_LE_WELLDEF)
+
+lemma NADD_LE_REFL: "nadd_le x x"
+  by (import hollight NADD_LE_REFL)
+
+lemma NADD_LE_TRANS: "nadd_le x y & nadd_le y z ==> nadd_le x z"
+  by (import hollight NADD_LE_TRANS)
+
+lemma NADD_LE_ANTISYM: "(nadd_le x y & nadd_le y x) = nadd_eq x y"
+  by (import hollight NADD_LE_ANTISYM)
+
+lemma NADD_LE_TOTAL_LEMMA: "~ nadd_le x y ==> EX n. n ~= 0 & dest_nadd y n + B < dest_nadd x n"
+  by (import hollight NADD_LE_TOTAL_LEMMA)
+
+lemma NADD_LE_TOTAL: "nadd_le x y | nadd_le y x"
+  by (import hollight NADD_LE_TOTAL)
+
+lemma NADD_ARCH: "EX xa. nadd_le x (nadd_of_num xa)"
+  by (import hollight NADD_ARCH)
+
+lemma NADD_OF_NUM_LE: "nadd_le (nadd_of_num m) (nadd_of_num n) = (m <= n)"
+  by (import hollight NADD_OF_NUM_LE)
+
+definition
+  nadd_add :: "nadd => nadd => nadd"  where
+  "nadd_add == %u ua. mk_nadd (%n. dest_nadd u n + dest_nadd ua n)"
+
+lemma DEF_nadd_add: "nadd_add = (%u ua. mk_nadd (%n. dest_nadd u n + dest_nadd ua n))"
+  by (import hollight DEF_nadd_add)
+
+lemma NADD_ADD: "dest_nadd (nadd_add x y) = (%n. dest_nadd x n + dest_nadd y n)"
+  by (import hollight NADD_ADD)
+
+lemma NADD_ADD_WELLDEF: "nadd_eq x x' & nadd_eq y y' ==> nadd_eq (nadd_add x y) (nadd_add x' y')"
+  by (import hollight NADD_ADD_WELLDEF)
+
+lemma NADD_ADD_SYM: "nadd_eq (nadd_add x y) (nadd_add y x)"
+  by (import hollight NADD_ADD_SYM)
+
+lemma NADD_ADD_ASSOC: "nadd_eq (nadd_add x (nadd_add y z)) (nadd_add (nadd_add x y) z)"
+  by (import hollight NADD_ADD_ASSOC)
+
+lemma NADD_ADD_LID: "nadd_eq (nadd_add (nadd_of_num 0) x) x"
+  by (import hollight NADD_ADD_LID)
+
+lemma NADD_ADD_LCANCEL: "nadd_eq (nadd_add x y) (nadd_add x z) ==> nadd_eq y z"
+  by (import hollight NADD_ADD_LCANCEL)
+
+lemma NADD_LE_ADD: "nadd_le x (nadd_add x y)"
+  by (import hollight NADD_LE_ADD)
+
+lemma NADD_LE_EXISTS: "nadd_le x y ==> EX d. nadd_eq y (nadd_add x d)"
+  by (import hollight NADD_LE_EXISTS)
+
+lemma NADD_OF_NUM_ADD: "nadd_eq (nadd_add (nadd_of_num x) (nadd_of_num xa)) (nadd_of_num (x + xa))"
+  by (import hollight NADD_OF_NUM_ADD)
+
+definition
+  nadd_mul :: "nadd => nadd => nadd"  where
+  "nadd_mul == %u ua. mk_nadd (%n. dest_nadd u (dest_nadd ua n))"
+
+lemma DEF_nadd_mul: "nadd_mul = (%u ua. mk_nadd (%n. dest_nadd u (dest_nadd ua n)))"
+  by (import hollight DEF_nadd_mul)
+
+lemma NADD_MUL: "dest_nadd (nadd_mul x y) = (%n. dest_nadd x (dest_nadd y n))"
+  by (import hollight NADD_MUL)
+
+lemma NADD_MUL_SYM: "nadd_eq (nadd_mul x y) (nadd_mul y x)"
+  by (import hollight NADD_MUL_SYM)
+
+lemma NADD_MUL_ASSOC: "nadd_eq (nadd_mul x (nadd_mul y z)) (nadd_mul (nadd_mul x y) z)"
+  by (import hollight NADD_MUL_ASSOC)
+
+lemma NADD_MUL_LID: "nadd_eq (nadd_mul (nadd_of_num 1) x) x"
+  by (import hollight NADD_MUL_LID)
+
+lemma NADD_LDISTRIB: "nadd_eq (nadd_mul x (nadd_add y z)) (nadd_add (nadd_mul x y) (nadd_mul x z))"
+  by (import hollight NADD_LDISTRIB)
+
+lemma NADD_MUL_WELLDEF_LEMMA: "nadd_eq y y' ==> nadd_eq (nadd_mul x y) (nadd_mul x y')"
+  by (import hollight NADD_MUL_WELLDEF_LEMMA)
+
+lemma NADD_MUL_WELLDEF: "nadd_eq x x' & nadd_eq y y' ==> nadd_eq (nadd_mul x y) (nadd_mul x' y')"
+  by (import hollight NADD_MUL_WELLDEF)
+
+lemma NADD_OF_NUM_MUL: "nadd_eq (nadd_mul (nadd_of_num x) (nadd_of_num xa)) (nadd_of_num (x * xa))"
+  by (import hollight NADD_OF_NUM_MUL)
+
+lemma NADD_LE_0: "nadd_le (nadd_of_num 0) x"
+  by (import hollight NADD_LE_0)
+
+lemma NADD_EQ_IMP_LE: "nadd_eq x y ==> nadd_le x y"
+  by (import hollight NADD_EQ_IMP_LE)
+
+lemma NADD_LE_LMUL: "nadd_le y z ==> nadd_le (nadd_mul x y) (nadd_mul x z)"
+  by (import hollight NADD_LE_LMUL)
+
+lemma NADD_LE_RMUL: "nadd_le x y ==> nadd_le (nadd_mul x z) (nadd_mul y z)"
+  by (import hollight NADD_LE_RMUL)
+
+lemma NADD_LE_RADD: "nadd_le (nadd_add x z) (nadd_add y z) = nadd_le x y"
+  by (import hollight NADD_LE_RADD)
+
+lemma NADD_LE_LADD: "nadd_le (nadd_add x y) (nadd_add x z) = nadd_le y z"
+  by (import hollight NADD_LE_LADD)
+
+lemma NADD_RDISTRIB: "nadd_eq (nadd_mul (nadd_add x y) z) (nadd_add (nadd_mul x z) (nadd_mul y z))"
+  by (import hollight NADD_RDISTRIB)
+
+lemma NADD_ARCH_MULT: "~ nadd_eq x (nadd_of_num 0)
+==> EX xa. nadd_le (nadd_of_num k) (nadd_mul (nadd_of_num xa) x)"
+  by (import hollight NADD_ARCH_MULT)
+
+lemma NADD_ARCH_ZERO: "(!!n. nadd_le (nadd_mul (nadd_of_num n) x) k) ==> nadd_eq x (nadd_of_num 0)"
+  by (import hollight NADD_ARCH_ZERO)
+
+lemma NADD_ARCH_LEMMA: "(!!n. nadd_le (nadd_mul (nadd_of_num n) x)
+       (nadd_add (nadd_mul (nadd_of_num n) y) z))
+==> nadd_le x y"
+  by (import hollight NADD_ARCH_LEMMA)
+
+lemma NADD_COMPLETE: "Ex P & (EX M. ALL x. P x --> nadd_le x M)
+==> EX M. (ALL x. P x --> nadd_le x M) &
+          (ALL M'. (ALL x. P x --> nadd_le x M') --> nadd_le M M')"
+  by (import hollight NADD_COMPLETE)
+
+lemma NADD_UBOUND: "EX xa N. ALL n>=N. dest_nadd x n <= xa * n"
+  by (import hollight NADD_UBOUND)
+
+lemma NADD_NONZERO: "~ nadd_eq x (nadd_of_num 0) ==> EX N. ALL n>=N. dest_nadd x n ~= 0"
+  by (import hollight NADD_NONZERO)
+
+lemma NADD_LBOUND: "~ nadd_eq x (nadd_of_num 0) ==> EX A N. ALL n>=N. n <= A * dest_nadd x n"
+  by (import hollight NADD_LBOUND)
+
+definition
+  nadd_rinv :: "nadd => nat => nat"  where
+  "nadd_rinv == %u n. n * n div dest_nadd u n"
+
+lemma DEF_nadd_rinv: "nadd_rinv = (%u n. n * n div dest_nadd u n)"
+  by (import hollight DEF_nadd_rinv)
+
+lemma NADD_MUL_LINV_LEMMA0: "~ nadd_eq x (nadd_of_num 0) ==> EX xa B. ALL i. nadd_rinv x i <= xa * i + B"
+  by (import hollight NADD_MUL_LINV_LEMMA0)
+
+lemma NADD_MUL_LINV_LEMMA1: "dest_nadd x n ~= 0
+==> hollight.dist (dest_nadd x n * nadd_rinv x n, n * n) <= dest_nadd x n"
+  by (import hollight NADD_MUL_LINV_LEMMA1)
+
+lemma NADD_MUL_LINV_LEMMA2: "~ nadd_eq x (nadd_of_num 0)
+==> EX N. ALL n>=N.
+             hollight.dist (dest_nadd x n * nadd_rinv x n, n * n)
+             <= dest_nadd x n"
+  by (import hollight NADD_MUL_LINV_LEMMA2)
+
+lemma NADD_MUL_LINV_LEMMA3: "~ nadd_eq x (nadd_of_num 0)
+==> EX N. ALL m n.
+             N <= n -->
+             hollight.dist
+              (m * (dest_nadd x m * (dest_nadd x n * nadd_rinv x n)),
+               m * (dest_nadd x m * (n * n)))
+             <= m * (dest_nadd x m * dest_nadd x n)"
+  by (import hollight NADD_MUL_LINV_LEMMA3)
+
+lemma NADD_MUL_LINV_LEMMA4: "~ nadd_eq x (nadd_of_num 0)
+==> EX N. ALL m n.
+             N <= m & N <= n -->
+             dest_nadd x m * dest_nadd x n *
+             hollight.dist (m * nadd_rinv x n, n * nadd_rinv x m)
+             <= m * n *
+                hollight.dist (m * dest_nadd x n, n * dest_nadd x m) +
+                dest_nadd x m * dest_nadd x n * (m + n)"
+  by (import hollight NADD_MUL_LINV_LEMMA4)
+
+lemma NADD_MUL_LINV_LEMMA5: "~ nadd_eq x (nadd_of_num 0)
+==> EX B N.
+       ALL m n.
+          N <= m & N <= n -->
+          dest_nadd x m * dest_nadd x n *
+          hollight.dist (m * nadd_rinv x n, n * nadd_rinv x m)
+          <= B * (m * n * (m + n))"
+  by (import hollight NADD_MUL_LINV_LEMMA5)
+
+lemma NADD_MUL_LINV_LEMMA6: "~ nadd_eq x (nadd_of_num 0)
+==> EX B N.
+       ALL m n.
+          N <= m & N <= n -->
+          m * n * hollight.dist (m * nadd_rinv x n, n * nadd_rinv x m)
+          <= B * (m * n * (m + n))"
+  by (import hollight NADD_MUL_LINV_LEMMA6)
+
+lemma NADD_MUL_LINV_LEMMA7: "~ nadd_eq x (nadd_of_num 0)
+==> EX B N.
+       ALL m n.
+          N <= m & N <= n -->
+          hollight.dist (m * nadd_rinv x n, n * nadd_rinv x m)
+          <= B * (m + n)"
+  by (import hollight NADD_MUL_LINV_LEMMA7)
+
+lemma NADD_MUL_LINV_LEMMA7a: "~ nadd_eq x (nadd_of_num 0)
+==> EX A B.
+       ALL m n.
+          m <= N -->
+          hollight.dist (m * nadd_rinv x n, n * nadd_rinv x m) <= A * n + B"
+  by (import hollight NADD_MUL_LINV_LEMMA7a)
+
+lemma NADD_MUL_LINV_LEMMA8: "~ nadd_eq x (nadd_of_num 0)
+==> EX B. ALL m n.
+             hollight.dist (m * nadd_rinv x n, n * nadd_rinv x m)
+             <= B * (m + n)"
+  by (import hollight NADD_MUL_LINV_LEMMA8)
+
+definition
+  nadd_inv :: "nadd => nadd"  where
+  "nadd_inv ==
+%u. if nadd_eq u (nadd_of_num 0) then nadd_of_num 0
+    else mk_nadd (nadd_rinv u)"
+
+lemma DEF_nadd_inv: "nadd_inv =
+(%u. if nadd_eq u (nadd_of_num 0) then nadd_of_num 0
+     else mk_nadd (nadd_rinv u))"
+  by (import hollight DEF_nadd_inv)
+
+lemma NADD_INV: "dest_nadd (nadd_inv x) =
+(if nadd_eq x (nadd_of_num 0) then %n. 0 else nadd_rinv x)"
+  by (import hollight NADD_INV)
+
+lemma NADD_MUL_LINV: "~ nadd_eq x (nadd_of_num 0)
+==> nadd_eq (nadd_mul (nadd_inv x) x) (nadd_of_num 1)"
+  by (import hollight NADD_MUL_LINV)
+
+lemma NADD_INV_0: "nadd_eq (nadd_inv (nadd_of_num 0)) (nadd_of_num 0)"
+  by (import hollight NADD_INV_0)
+
+lemma NADD_INV_WELLDEF: "nadd_eq x y ==> nadd_eq (nadd_inv x) (nadd_inv y)"
+  by (import hollight NADD_INV_WELLDEF)
+
+typedef (open) hreal = "{s. EX x. s = nadd_eq x}"  morphisms "dest_hreal" "mk_hreal"
+  apply (rule light_ex_imp_nonempty[where t="nadd_eq x"])
+  by (import hollight TYDEF_hreal)
+
+syntax
+  dest_hreal :: _ 
+
+syntax
+  mk_hreal :: _ 
+
+lemmas "TYDEF_hreal_@intern" = typedef_hol2hollight 
+  [where a="a :: hreal" and r=r ,
+   OF type_definition_hreal]
+
+definition
+  hreal_of_num :: "nat => hreal"  where
+  "hreal_of_num == %m. mk_hreal (nadd_eq (nadd_of_num m))"
+
+lemma DEF_hreal_of_num: "hreal_of_num = (%m. mk_hreal (nadd_eq (nadd_of_num m)))"
+  by (import hollight DEF_hreal_of_num)
+
+definition
+  hreal_add :: "hreal => hreal => hreal"  where
+  "hreal_add ==
+%x y. mk_hreal
+       (%u. EX xa ya.
+               nadd_eq (nadd_add xa ya) u &
+               dest_hreal x xa & dest_hreal y ya)"
+
+lemma DEF_hreal_add: "hreal_add =
+(%x y. mk_hreal
+        (%u. EX xa ya.
+                nadd_eq (nadd_add xa ya) u &
+                dest_hreal x xa & dest_hreal y ya))"
+  by (import hollight DEF_hreal_add)
+
+definition
+  hreal_mul :: "hreal => hreal => hreal"  where
+  "hreal_mul ==
+%x y. mk_hreal
+       (%u. EX xa ya.
+               nadd_eq (nadd_mul xa ya) u &
+               dest_hreal x xa & dest_hreal y ya)"
+
+lemma DEF_hreal_mul: "hreal_mul =
+(%x y. mk_hreal
+        (%u. EX xa ya.
+                nadd_eq (nadd_mul xa ya) u &
+                dest_hreal x xa & dest_hreal y ya))"
+  by (import hollight DEF_hreal_mul)
+
+definition
+  hreal_le :: "hreal => hreal => bool"  where
+  "hreal_le ==
+%x y. SOME u.
+         EX xa ya. nadd_le xa ya = u & dest_hreal x xa & dest_hreal y ya"
+
+lemma DEF_hreal_le: "hreal_le =
+(%x y. SOME u.
+          EX xa ya. nadd_le xa ya = u & dest_hreal x xa & dest_hreal y ya)"
+  by (import hollight DEF_hreal_le)
+
+definition
+  hreal_inv :: "hreal => hreal"  where
+  "hreal_inv ==
+%x. mk_hreal (%u. EX xa. nadd_eq (nadd_inv xa) u & dest_hreal x xa)"
+
+lemma DEF_hreal_inv: "hreal_inv =
+(%x. mk_hreal (%u. EX xa. nadd_eq (nadd_inv xa) u & dest_hreal x xa))"
+  by (import hollight DEF_hreal_inv)
+
+lemma HREAL_LE_EXISTS_DEF: "hreal_le m n = (EX d. n = hreal_add m d)"
+  by (import hollight HREAL_LE_EXISTS_DEF)
+
+lemma HREAL_EQ_ADD_LCANCEL: "(hreal_add m n = hreal_add m p) = (n = p)"
+  by (import hollight HREAL_EQ_ADD_LCANCEL)
+
+lemma HREAL_EQ_ADD_RCANCEL: "(hreal_add x xb = hreal_add xa xb) = (x = xa)"
+  by (import hollight HREAL_EQ_ADD_RCANCEL)
+
+lemma HREAL_LE_ADD_LCANCEL: "hreal_le (hreal_add x xa) (hreal_add x xb) = hreal_le xa xb"
+  by (import hollight HREAL_LE_ADD_LCANCEL)
+
+lemma HREAL_LE_ADD_RCANCEL: "hreal_le (hreal_add x xb) (hreal_add xa xb) = hreal_le x xa"
+  by (import hollight HREAL_LE_ADD_RCANCEL)
+
+lemma HREAL_ADD_RID: "hreal_add x (hreal_of_num 0) = x"
+  by (import hollight HREAL_ADD_RID)
+
+lemma HREAL_ADD_RDISTRIB: "hreal_mul (hreal_add x xa) xb = hreal_add (hreal_mul x xb) (hreal_mul xa xb)"
+  by (import hollight HREAL_ADD_RDISTRIB)
+
+lemma HREAL_MUL_LZERO: "hreal_mul (hreal_of_num 0) m = hreal_of_num 0"
+  by (import hollight HREAL_MUL_LZERO)
+
+lemma HREAL_MUL_RZERO: "hreal_mul x (hreal_of_num 0) = hreal_of_num 0"
+  by (import hollight HREAL_MUL_RZERO)
+
+lemma HREAL_ADD_AC: "hreal_add m n = hreal_add n m &
+hreal_add (hreal_add m n) p = hreal_add m (hreal_add n p) &
+hreal_add m (hreal_add n p) = hreal_add n (hreal_add m p)"
+  by (import hollight HREAL_ADD_AC)
+
+lemma HREAL_LE_ADD2: "hreal_le a b & hreal_le c d ==> hreal_le (hreal_add a c) (hreal_add b d)"
+  by (import hollight HREAL_LE_ADD2)
+
+lemma HREAL_LE_MUL_RCANCEL_IMP: "hreal_le a b ==> hreal_le (hreal_mul a c) (hreal_mul b c)"
+  by (import hollight HREAL_LE_MUL_RCANCEL_IMP)
+
+definition
+  treal_of_num :: "nat => hreal * hreal"  where
+  "treal_of_num == %u. (hreal_of_num u, hreal_of_num 0)"
+
+lemma DEF_treal_of_num: "treal_of_num = (%u. (hreal_of_num u, hreal_of_num 0))"
+  by (import hollight DEF_treal_of_num)
+
+definition
+  treal_neg :: "hreal * hreal => hreal * hreal"  where
+  "treal_neg == %u. (snd u, fst u)"
+
+lemma DEF_treal_neg: "treal_neg = (%u. (snd u, fst u))"
+  by (import hollight DEF_treal_neg)
+
+definition
+  treal_add :: "hreal * hreal => hreal * hreal => hreal * hreal"  where
+  "treal_add == %u ua. (hreal_add (fst u) (fst ua), hreal_add (snd u) (snd ua))"
+
+lemma DEF_treal_add: "treal_add =
+(%u ua. (hreal_add (fst u) (fst ua), hreal_add (snd u) (snd ua)))"
+  by (import hollight DEF_treal_add)
+
+definition
+  treal_mul :: "hreal * hreal => hreal * hreal => hreal * hreal"  where
+  "treal_mul ==
+%u ua.
+   (hreal_add (hreal_mul (fst u) (fst ua)) (hreal_mul (snd u) (snd ua)),
+    hreal_add (hreal_mul (fst u) (snd ua)) (hreal_mul (snd u) (fst ua)))"
+
+lemma DEF_treal_mul: "treal_mul =
+(%u ua.
+    (hreal_add (hreal_mul (fst u) (fst ua)) (hreal_mul (snd u) (snd ua)),
+     hreal_add (hreal_mul (fst u) (snd ua)) (hreal_mul (snd u) (fst ua))))"
+  by (import hollight DEF_treal_mul)
+
+definition
+  treal_le :: "hreal * hreal => hreal * hreal => bool"  where
+  "treal_le ==
+%u ua. hreal_le (hreal_add (fst u) (snd ua)) (hreal_add (fst ua) (snd u))"
+
+lemma DEF_treal_le: "treal_le =
+(%u ua. hreal_le (hreal_add (fst u) (snd ua)) (hreal_add (fst ua) (snd u)))"
+  by (import hollight DEF_treal_le)
+
+definition
+  treal_inv :: "hreal * hreal => hreal * hreal"  where
+  "treal_inv ==
+%u. if fst u = snd u then (hreal_of_num 0, hreal_of_num 0)
+    else if hreal_le (snd u) (fst u)
+         then (hreal_inv (SOME d. fst u = hreal_add (snd u) d),
+               hreal_of_num 0)
+         else (hreal_of_num 0,
+               hreal_inv (SOME d. snd u = hreal_add (fst u) d))"
+
+lemma DEF_treal_inv: "treal_inv =
+(%u. if fst u = snd u then (hreal_of_num 0, hreal_of_num 0)
+     else if hreal_le (snd u) (fst u)
+          then (hreal_inv (SOME d. fst u = hreal_add (snd u) d),
+                hreal_of_num 0)
+          else (hreal_of_num 0,
+                hreal_inv (SOME d. snd u = hreal_add (fst u) d)))"
+  by (import hollight DEF_treal_inv)
+
+definition
+  treal_eq :: "hreal * hreal => hreal * hreal => bool"  where
+  "treal_eq == %u ua. hreal_add (fst u) (snd ua) = hreal_add (fst ua) (snd u)"
+
+lemma DEF_treal_eq: "treal_eq = (%u ua. hreal_add (fst u) (snd ua) = hreal_add (fst ua) (snd u))"
+  by (import hollight DEF_treal_eq)
+
+lemma TREAL_EQ_REFL: "treal_eq x x"
+  by (import hollight TREAL_EQ_REFL)
+
+lemma TREAL_EQ_SYM: "treal_eq x y = treal_eq y x"
+  by (import hollight TREAL_EQ_SYM)
+
+lemma TREAL_EQ_TRANS: "treal_eq x y & treal_eq y z ==> treal_eq x z"
+  by (import hollight TREAL_EQ_TRANS)
+
+lemma TREAL_EQ_AP: "x = xa ==> treal_eq x xa"
+  by (import hollight TREAL_EQ_AP)
+
+lemma TREAL_OF_NUM_EQ: "treal_eq (treal_of_num x) (treal_of_num xa) = (x = xa)"
+  by (import hollight TREAL_OF_NUM_EQ)
+
+lemma TREAL_OF_NUM_LE: "treal_le (treal_of_num x) (treal_of_num xa) = (x <= xa)"
+  by (import hollight TREAL_OF_NUM_LE)
+
+lemma TREAL_OF_NUM_ADD: "treal_eq (treal_add (treal_of_num x) (treal_of_num xa))
+ (treal_of_num (x + xa))"
+  by (import hollight TREAL_OF_NUM_ADD)
+
+lemma TREAL_OF_NUM_MUL: "treal_eq (treal_mul (treal_of_num x) (treal_of_num xa))
+ (treal_of_num (x * xa))"
+  by (import hollight TREAL_OF_NUM_MUL)
+
+lemma TREAL_ADD_SYM_EQ: "treal_add x y = treal_add y x"
+  by (import hollight TREAL_ADD_SYM_EQ)
+
+lemma TREAL_MUL_SYM_EQ: "treal_mul x y = treal_mul y x"
+  by (import hollight TREAL_MUL_SYM_EQ)
+
+lemma TREAL_ADD_SYM: "treal_eq (treal_add x y) (treal_add y x)"
+  by (import hollight TREAL_ADD_SYM)
+
+lemma TREAL_ADD_ASSOC: "treal_eq (treal_add x (treal_add y z)) (treal_add (treal_add x y) z)"
+  by (import hollight TREAL_ADD_ASSOC)
+
+lemma TREAL_ADD_LID: "treal_eq (treal_add (treal_of_num 0) x) x"
+  by (import hollight TREAL_ADD_LID)
+
+lemma TREAL_ADD_LINV: "treal_eq (treal_add (treal_neg x) x) (treal_of_num 0)"
+  by (import hollight TREAL_ADD_LINV)
+
+lemma TREAL_MUL_SYM: "treal_eq (treal_mul x xa) (treal_mul xa x)"
+  by (import hollight TREAL_MUL_SYM)
+
+lemma TREAL_MUL_ASSOC: "treal_eq (treal_mul x (treal_mul y z)) (treal_mul (treal_mul x y) z)"
+  by (import hollight TREAL_MUL_ASSOC)
+
+lemma TREAL_MUL_LID: "treal_eq (treal_mul (treal_of_num 1) x) x"
+  by (import hollight TREAL_MUL_LID)
+
+lemma TREAL_ADD_LDISTRIB: "treal_eq (treal_mul x (treal_add y z))
+ (treal_add (treal_mul x y) (treal_mul x z))"
+  by (import hollight TREAL_ADD_LDISTRIB)
+
+lemma TREAL_LE_REFL: "treal_le x x"
+  by (import hollight TREAL_LE_REFL)
+
+lemma TREAL_LE_ANTISYM: "(treal_le x y & treal_le y x) = treal_eq x y"
+  by (import hollight TREAL_LE_ANTISYM)
+
+lemma TREAL_LE_TRANS: "treal_le x y & treal_le y z ==> treal_le x z"
+  by (import hollight TREAL_LE_TRANS)
+
+lemma TREAL_LE_TOTAL: "treal_le x y | treal_le y x"
+  by (import hollight TREAL_LE_TOTAL)
+
+lemma TREAL_LE_LADD_IMP: "treal_le y z ==> treal_le (treal_add x y) (treal_add x z)"
+  by (import hollight TREAL_LE_LADD_IMP)
+
+lemma TREAL_LE_MUL: "treal_le (treal_of_num 0) x & treal_le (treal_of_num 0) y
+==> treal_le (treal_of_num 0) (treal_mul x y)"
+  by (import hollight TREAL_LE_MUL)
+
+lemma TREAL_INV_0: "treal_eq (treal_inv (treal_of_num 0)) (treal_of_num 0)"
+  by (import hollight TREAL_INV_0)
+
+lemma TREAL_MUL_LINV: "~ treal_eq x (treal_of_num 0)
+==> treal_eq (treal_mul (treal_inv x) x) (treal_of_num 1)"
+  by (import hollight TREAL_MUL_LINV)
+
+lemma TREAL_OF_NUM_WELLDEF: "m = n ==> treal_eq (treal_of_num m) (treal_of_num n)"
+  by (import hollight TREAL_OF_NUM_WELLDEF)
+
+lemma TREAL_NEG_WELLDEF: "treal_eq x1 x2 ==> treal_eq (treal_neg x1) (treal_neg x2)"
+  by (import hollight TREAL_NEG_WELLDEF)
+
+lemma TREAL_ADD_WELLDEFR: "treal_eq x1 x2 ==> treal_eq (treal_add x1 y) (treal_add x2 y)"
+  by (import hollight 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 hollight TREAL_ADD_WELLDEF)
+
+lemma TREAL_MUL_WELLDEFR: "treal_eq x1 x2 ==> treal_eq (treal_mul x1 y) (treal_mul x2 y)"
+  by (import hollight 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 hollight TREAL_MUL_WELLDEF)
+
+lemma TREAL_EQ_IMP_LE: "treal_eq x y ==> treal_le x y"
+  by (import hollight TREAL_EQ_IMP_LE)
+
+lemma TREAL_LE_WELLDEF: "treal_eq x1 x2 & treal_eq y1 y2 ==> treal_le x1 y1 = treal_le x2 y2"
+  by (import hollight TREAL_LE_WELLDEF)
+
+lemma TREAL_INV_WELLDEF: "treal_eq x y ==> treal_eq (treal_inv x) (treal_inv y)"
+  by (import hollight TREAL_INV_WELLDEF)
+
+typedef (open) real = "{s. EX x. s = treal_eq x}"  morphisms "dest_real" "mk_real"
+  apply (rule light_ex_imp_nonempty[where t="treal_eq x"])
+  by (import hollight TYDEF_real)
+
+syntax
+  dest_real :: _ 
+
+syntax
+  mk_real :: _ 
+
+lemmas "TYDEF_real_@intern" = typedef_hol2hollight 
+  [where a="a :: hollight.real" and r=r ,
+   OF type_definition_real]
+
+definition
+  real_of_num :: "nat => hollight.real"  where
+  "real_of_num == %m. mk_real (treal_eq (treal_of_num m))"
+
+lemma DEF_real_of_num: "real_of_num = (%m. mk_real (treal_eq (treal_of_num m)))"
+  by (import hollight DEF_real_of_num)
+
+definition
+  real_neg :: "hollight.real => hollight.real"  where
+  "real_neg ==
+%x1. mk_real (%u. EX x1a. treal_eq (treal_neg x1a) u & dest_real x1 x1a)"
+
+lemma DEF_real_neg: "real_neg =
+(%x1. mk_real (%u. EX x1a. treal_eq (treal_neg x1a) u & dest_real x1 x1a))"
+  by (import hollight DEF_real_neg)
+
+definition
+  real_add :: "hollight.real => hollight.real => hollight.real"  where
+  "real_add ==
+%x1 y1.
+   mk_real
+    (%u. EX x1a y1a.
+            treal_eq (treal_add x1a y1a) u &
+            dest_real x1 x1a & dest_real y1 y1a)"
+
+lemma DEF_real_add: "real_add =
+(%x1 y1.
+    mk_real
+     (%u. EX x1a y1a.
+             treal_eq (treal_add x1a y1a) u &
+             dest_real x1 x1a & dest_real y1 y1a))"
+  by (import hollight DEF_real_add)
+
+definition
+  real_mul :: "hollight.real => hollight.real => hollight.real"  where
+  "real_mul ==
+%x1 y1.
+   mk_real
+    (%u. EX x1a y1a.
+            treal_eq (treal_mul x1a y1a) u &
+            dest_real x1 x1a & dest_real y1 y1a)"
+
+lemma DEF_real_mul: "real_mul =
+(%x1 y1.
+    mk_real
+     (%u. EX x1a y1a.
+             treal_eq (treal_mul x1a y1a) u &
+             dest_real x1 x1a & dest_real y1 y1a))"
+  by (import hollight DEF_real_mul)
+
+definition
+  real_le :: "hollight.real => hollight.real => bool"  where
+  "real_le ==
+%x1 y1.
+   SOME u.
+      EX x1a y1a. treal_le x1a y1a = u & dest_real x1 x1a & dest_real y1 y1a"
+
+lemma DEF_real_le: "real_le =
+(%x1 y1.
+    SOME u.
+       EX x1a y1a.
+          treal_le x1a y1a = u & dest_real x1 x1a & dest_real y1 y1a)"
+  by (import hollight DEF_real_le)
+
+definition
+  real_inv :: "hollight.real => hollight.real"  where
+  "real_inv ==
+%x. mk_real (%u. EX xa. treal_eq (treal_inv xa) u & dest_real x xa)"
+
+lemma DEF_real_inv: "real_inv =
+(%x. mk_real (%u. EX xa. treal_eq (treal_inv xa) u & dest_real x xa))"
+  by (import hollight DEF_real_inv)
+
+definition
+  real_sub :: "hollight.real => hollight.real => hollight.real"  where
+  "real_sub == %u ua. real_add u (real_neg ua)"
+
+lemma DEF_real_sub: "real_sub = (%u ua. real_add u (real_neg ua))"
+  by (import hollight DEF_real_sub)
+
+definition
+  real_lt :: "hollight.real => hollight.real => bool"  where
+  "real_lt == %u ua. ~ real_le ua u"
+
+lemma DEF_real_lt: "real_lt = (%u ua. ~ real_le ua u)"
+  by (import hollight DEF_real_lt)
+
+definition
+  real_ge :: "hollight.real => hollight.real => bool"  where
+  "real_ge == %u ua. real_le ua u"
+
+lemma DEF_real_ge: "real_ge = (%u ua. real_le ua u)"
+  by (import hollight DEF_real_ge)
+
+definition
+  real_gt :: "hollight.real => hollight.real => bool"  where
+  "real_gt == %u ua. real_lt ua u"
+
+lemma DEF_real_gt: "real_gt = (%u ua. real_lt ua u)"
+  by (import hollight DEF_real_gt)
+
+definition
+  real_abs :: "hollight.real => hollight.real"  where
+  "real_abs == %u. if real_le (real_of_num 0) u then u else real_neg u"
+
+lemma DEF_real_abs: "real_abs = (%u. if real_le (real_of_num 0) u then u else real_neg u)"
+  by (import hollight DEF_real_abs)
+
+definition
+  real_pow :: "hollight.real => nat => hollight.real"  where
+  "real_pow ==
+SOME real_pow.
+   (ALL x. real_pow x 0 = real_of_num 1) &
+   (ALL x n. real_pow x (Suc n) = real_mul x (real_pow x n))"
+
+lemma DEF_real_pow: "real_pow =
+(SOME real_pow.
+    (ALL x. real_pow x 0 = real_of_num 1) &
+    (ALL x n. real_pow x (Suc n) = real_mul x (real_pow x n)))"
+  by (import hollight DEF_real_pow)
+
+definition
+  real_div :: "hollight.real => hollight.real => hollight.real"  where
+  "real_div == %u ua. real_mul u (real_inv ua)"
+
+lemma DEF_real_div: "real_div = (%u ua. real_mul u (real_inv ua))"
+  by (import hollight DEF_real_div)
+
+definition
+  real_max :: "hollight.real => hollight.real => hollight.real"  where
+  "real_max == %u ua. if real_le u ua then ua else u"
+
+lemma DEF_real_max: "real_max = (%u ua. if real_le u ua then ua else u)"
+  by (import hollight DEF_real_max)
+
+definition
+  real_min :: "hollight.real => hollight.real => hollight.real"  where
+  "real_min == %u ua. if real_le u ua then u else ua"
+
+lemma DEF_real_min: "real_min = (%u ua. if real_le u ua then u else ua)"
+  by (import hollight DEF_real_min)
+
+lemma REAL_HREAL_LEMMA1: "EX x. (ALL xa. real_le (real_of_num 0) xa = (EX y. xa = x y)) &
+      (ALL y z. hreal_le y z = real_le (x y) (x z))"
+  by (import hollight REAL_HREAL_LEMMA1)
+
+lemma REAL_HREAL_LEMMA2: "EX x r.
+   (ALL xa. x (r xa) = xa) &
+   (ALL xa. real_le (real_of_num 0) xa --> r (x xa) = xa) &
+   (ALL x. real_le (real_of_num 0) (r x)) &
+   (ALL x y. hreal_le x y = real_le (r x) (r y))"
+  by (import hollight REAL_HREAL_LEMMA2)
+
+lemma REAL_COMPLETE_SOMEPOS: "(EX x. P x & real_le (real_of_num 0) x) & (EX M. ALL x. P x --> real_le x M)
+==> EX M. (ALL x. P x --> real_le x M) &
+          (ALL M'. (ALL x. P x --> real_le x M') --> real_le M M')"
+  by (import hollight REAL_COMPLETE_SOMEPOS)
+
+lemma REAL_COMPLETE: "Ex P & (EX M. ALL x. P x --> real_le x M)
+==> EX M. (ALL x. P x --> real_le x M) &
+          (ALL M'. (ALL x. P x --> real_le x M') --> real_le M M')"
+  by (import hollight REAL_COMPLETE)
+
+lemma REAL_ADD_AC: "real_add m n = real_add n m &
+real_add (real_add m n) p = real_add m (real_add n p) &
+real_add m (real_add n p) = real_add n (real_add m p)"
+  by (import hollight REAL_ADD_AC)
+
+lemma REAL_ADD_RINV: "real_add x (real_neg x) = real_of_num 0"
+  by (import hollight REAL_ADD_RINV)
+
+lemma REAL_EQ_ADD_LCANCEL: "(real_add x y = real_add x z) = (y = z)"
+  by (import hollight REAL_EQ_ADD_LCANCEL)
+
+lemma REAL_EQ_ADD_RCANCEL: "(real_add x z = real_add y z) = (x = y)"
+  by (import hollight REAL_EQ_ADD_RCANCEL)
+
+lemma REAL_MUL_RZERO: "real_mul x (real_of_num 0) = real_of_num 0"
+  by (import hollight REAL_MUL_RZERO)
+
+lemma REAL_MUL_LZERO: "real_mul (real_of_num 0) x = real_of_num 0"
+  by (import hollight REAL_MUL_LZERO)
+
+lemma REAL_NEG_NEG: "real_neg (real_neg x) = x"
+  by (import hollight REAL_NEG_NEG)
+
+lemma REAL_MUL_RNEG: "real_mul x (real_neg y) = real_neg (real_mul x y)"
+  by (import hollight REAL_MUL_RNEG)
+
+lemma REAL_MUL_LNEG: "real_mul (real_neg x) y = real_neg (real_mul x y)"
+  by (import hollight REAL_MUL_LNEG)
+
+lemma REAL_NEG_ADD: "real_neg (real_add x y) = real_add (real_neg x) (real_neg y)"
+  by (import hollight REAL_NEG_ADD)
+
+lemma REAL_ADD_RID: "real_add x (real_of_num 0) = x"
+  by (import hollight REAL_ADD_RID)
+
+lemma REAL_NEG_0: "real_neg (real_of_num 0) = real_of_num 0"
+  by (import hollight REAL_NEG_0)
+
+lemma REAL_LE_LNEG: "real_le (real_neg x) y = real_le (real_of_num 0) (real_add x y)"
+  by (import hollight REAL_LE_LNEG)
+
+lemma REAL_LE_NEG2: "real_le (real_neg x) (real_neg y) = real_le y x"
+  by (import hollight REAL_LE_NEG2)
+
+lemma REAL_LE_RNEG: "real_le x (real_neg y) = real_le (real_add x y) (real_of_num 0)"
+  by (import hollight REAL_LE_RNEG)
+
+lemma REAL_OF_NUM_POW: "real_pow (real_of_num x) n = real_of_num (x ^ n)"
+  by (import hollight REAL_OF_NUM_POW)
+
+lemma REAL_POW_NEG: "real_pow (real_neg x) n =
+(if even n then real_pow x n else real_neg (real_pow x n))"
+  by (import hollight REAL_POW_NEG)
+
+lemma REAL_ABS_NUM: "real_abs (real_of_num x) = real_of_num x"
+  by (import hollight REAL_ABS_NUM)
+
+lemma REAL_ABS_NEG: "real_abs (real_neg x) = real_abs x"
+  by (import hollight REAL_ABS_NEG)
+
+lemma REAL_LTE_TOTAL: "real_lt x xa | real_le xa x"
+  by (import hollight REAL_LTE_TOTAL)
+
+lemma REAL_LET_TOTAL: "real_le x xa | real_lt xa x"
+  by (import hollight REAL_LET_TOTAL)
+
+lemma REAL_LT_IMP_LE: "real_lt x y ==> real_le x y"
+  by (import hollight REAL_LT_IMP_LE)
+
+lemma REAL_LTE_TRANS: "real_lt x y & real_le y z ==> real_lt x z"
+  by (import hollight REAL_LTE_TRANS)
+
+lemma REAL_LET_TRANS: "real_le x y & real_lt y z ==> real_lt x z"
+  by (import hollight REAL_LET_TRANS)
+
+lemma REAL_LT_TRANS: "real_lt x y & real_lt y z ==> real_lt x z"
+  by (import hollight REAL_LT_TRANS)
+
+lemma REAL_LE_ADD: "real_le (real_of_num 0) x & real_le (real_of_num 0) y
+==> real_le (real_of_num 0) (real_add x y)"
+  by (import hollight REAL_LE_ADD)
+
+lemma REAL_LTE_ANTISYM: "~ (real_lt x y & real_le y x)"
+  by (import hollight REAL_LTE_ANTISYM)
+
+lemma REAL_SUB_LE: "real_le (real_of_num 0) (real_sub x xa) = real_le xa x"
+  by (import hollight REAL_SUB_LE)
+
+lemma REAL_NEG_SUB: "real_neg (real_sub x xa) = real_sub xa x"
+  by (import hollight REAL_NEG_SUB)
+
+lemma REAL_LE_LT: "real_le x xa = (real_lt x xa | x = xa)"
+  by (import hollight REAL_LE_LT)
+
+lemma REAL_SUB_LT: "real_lt (real_of_num 0) (real_sub x xa) = real_lt xa x"
+  by (import hollight REAL_SUB_LT)
+
+lemma REAL_NOT_LT: "(~ real_lt x xa) = real_le xa x"
+  by (import hollight REAL_NOT_LT)
+
+lemma REAL_SUB_0: "(real_sub x y = real_of_num 0) = (x = y)"
+  by (import hollight REAL_SUB_0)
+
+lemma REAL_LT_LE: "real_lt x y = (real_le x y & x ~= y)"
+  by (import hollight REAL_LT_LE)
+
+lemma REAL_LT_REFL: "~ real_lt x x"
+  by (import hollight REAL_LT_REFL)
+
+lemma REAL_LTE_ADD: "real_lt (real_of_num 0) x & real_le (real_of_num 0) y
+==> real_lt (real_of_num 0) (real_add x y)"
+  by (import hollight REAL_LTE_ADD)
+
+lemma REAL_LET_ADD: "real_le (real_of_num 0) x & real_lt (real_of_num 0) y
+==> real_lt (real_of_num 0) (real_add x y)"
+  by (import hollight REAL_LET_ADD)
+
+lemma REAL_LT_ADD: "real_lt (real_of_num 0) x & real_lt (real_of_num 0) y
+==> real_lt (real_of_num 0) (real_add x y)"
+  by (import hollight REAL_LT_ADD)
+
+lemma REAL_ENTIRE: "(real_mul x y = real_of_num 0) = (x = real_of_num 0 | y = real_of_num 0)"
+  by (import hollight REAL_ENTIRE)
+
+lemma REAL_LE_NEGTOTAL: "real_le (real_of_num 0) x | real_le (real_of_num 0) (real_neg x)"
+  by (import hollight REAL_LE_NEGTOTAL)
+
+lemma REAL_LE_SQUARE: "real_le (real_of_num 0) (real_mul x x)"
+  by (import hollight REAL_LE_SQUARE)
+
+lemma REAL_MUL_RID: "real_mul x (real_of_num 1) = x"
+  by (import hollight REAL_MUL_RID)
+
+lemma REAL_POW_2: "real_pow x 2 = real_mul x x"
+  by (import hollight REAL_POW_2)
+
+lemma REAL_POLY_CLAUSES: "(ALL x y z. real_add x (real_add y z) = real_add (real_add x y) z) &
+(ALL x y. real_add x y = real_add y x) &
+(ALL x. real_add (real_of_num 0) x = x) &
+(ALL x y z. real_mul x (real_mul y z) = real_mul (real_mul x y) z) &
+(ALL x y. real_mul x y = real_mul y x) &
+(ALL x. real_mul (real_of_num 1) x = x) &
+(ALL x. real_mul (real_of_num 0) x = real_of_num 0) &
+(ALL x xa xb.
+    real_mul x (real_add xa xb) =
+    real_add (real_mul x xa) (real_mul x xb)) &
+(ALL x. real_pow x 0 = real_of_num 1) &
+(ALL x xa. real_pow x (Suc xa) = real_mul x (real_pow x xa))"
+  by (import hollight REAL_POLY_CLAUSES)
+
+lemma REAL_POLY_NEG_CLAUSES: "(ALL x. real_neg x = real_mul (real_neg (real_of_num 1)) x) &
+(ALL x xa.
+    real_sub x xa = real_add x (real_mul (real_neg (real_of_num 1)) xa))"
+  by (import hollight REAL_POLY_NEG_CLAUSES)
+
+lemma REAL_POS: "real_le (real_of_num 0) (real_of_num x)"
+  by (import hollight REAL_POS)
+
+lemma REAL_OF_NUM_LT: "real_lt (real_of_num x) (real_of_num xa) = (x < xa)"
+  by (import hollight REAL_OF_NUM_LT)
+
+lemma REAL_OF_NUM_GE: "real_ge (real_of_num x) (real_of_num xa) = (xa <= x)"
+  by (import hollight REAL_OF_NUM_GE)
+
+lemma REAL_OF_NUM_GT: "real_gt (real_of_num x) (real_of_num xa) = (xa < x)"
+  by (import hollight REAL_OF_NUM_GT)
+
+lemma REAL_OF_NUM_MAX: "real_max (real_of_num x) (real_of_num xa) = real_of_num (max x xa)"
+  by (import hollight REAL_OF_NUM_MAX)
+
+lemma REAL_OF_NUM_MIN: "real_min (real_of_num x) (real_of_num xa) = real_of_num (min x xa)"
+  by (import hollight REAL_OF_NUM_MIN)
+
+lemma REAL_OF_NUM_SUC: "real_add (real_of_num x) (real_of_num 1) = real_of_num (Suc x)"
+  by (import hollight REAL_OF_NUM_SUC)
+
+lemma REAL_OF_NUM_SUB: "m <= n ==> real_sub (real_of_num n) (real_of_num m) = real_of_num (n - m)"
+  by (import hollight REAL_OF_NUM_SUB)
+
+lemma REAL_MUL_AC: "real_mul m n = real_mul n m &
+real_mul (real_mul m n) p = real_mul m (real_mul n p) &
+real_mul m (real_mul n p) = real_mul n (real_mul m p)"
+  by (import hollight REAL_MUL_AC)
+
+lemma REAL_ADD_RDISTRIB: "real_mul (real_add x y) z = real_add (real_mul x z) (real_mul y z)"
+  by (import hollight REAL_ADD_RDISTRIB)
+
+lemma REAL_LT_LADD_IMP: "real_lt y z ==> real_lt (real_add x y) (real_add x z)"
+  by (import hollight REAL_LT_LADD_IMP)
+
+lemma REAL_LT_MUL: "real_lt (real_of_num 0) x & real_lt (real_of_num 0) y
+==> real_lt (real_of_num 0) (real_mul x y)"
+  by (import hollight REAL_LT_MUL)
+
+lemma REAL_EQ_ADD_LCANCEL_0: "(real_add x y = x) = (y = real_of_num 0)"
+  by (import hollight REAL_EQ_ADD_LCANCEL_0)
+
+lemma REAL_EQ_ADD_RCANCEL_0: "(real_add x y = y) = (x = real_of_num 0)"
+  by (import hollight REAL_EQ_ADD_RCANCEL_0)
+
+lemma REAL_LNEG_UNIQ: "(real_add x y = real_of_num 0) = (x = real_neg y)"
+  by (import hollight REAL_LNEG_UNIQ)
+
+lemma REAL_RNEG_UNIQ: "(real_add x y = real_of_num 0) = (y = real_neg x)"
+  by (import hollight REAL_RNEG_UNIQ)
+
+lemma REAL_NEG_LMUL: "real_neg (real_mul x y) = real_mul (real_neg x) y"
+  by (import hollight REAL_NEG_LMUL)
+
+lemma REAL_NEG_RMUL: "real_neg (real_mul x y) = real_mul x (real_neg y)"
+  by (import hollight REAL_NEG_RMUL)
+
+lemma REAL_NEGNEG: "real_neg (real_neg x) = x"
+  by (import hollight REAL_NEGNEG)
+
+lemma REAL_NEG_MUL2: "real_mul (real_neg x) (real_neg y) = real_mul x y"
+  by (import hollight REAL_NEG_MUL2)
+
+lemma REAL_LT_LADD: "real_lt (real_add x y) (real_add x z) = real_lt y z"
+  by (import hollight REAL_LT_LADD)
+
+lemma REAL_LT_RADD: "real_lt (real_add x z) (real_add y z) = real_lt x y"
+  by (import hollight REAL_LT_RADD)
+
+lemma REAL_LT_ANTISYM: "~ (real_lt x y & real_lt y x)"
+  by (import hollight REAL_LT_ANTISYM)
+
+lemma REAL_LT_GT: "real_lt x y ==> ~ real_lt y x"
+  by (import hollight REAL_LT_GT)
+
+lemma REAL_NOT_EQ: "(x ~= y) = (real_lt x y | real_lt y x)"
+  by (import hollight REAL_NOT_EQ)
+
+lemma REAL_LET_ANTISYM: "~ (real_le x y & real_lt y x)"
+  by (import hollight REAL_LET_ANTISYM)
+
+lemma REAL_NEG_LT0: "real_lt (real_neg x) (real_of_num 0) = real_lt (real_of_num 0) x"
+  by (import hollight REAL_NEG_LT0)
+
+lemma REAL_NEG_GT0: "real_lt (real_of_num 0) (real_neg x) = real_lt x (real_of_num 0)"
+  by (import hollight REAL_NEG_GT0)
+
+lemma REAL_NEG_LE0: "real_le (real_neg x) (real_of_num 0) = real_le (real_of_num 0) x"
+  by (import hollight REAL_NEG_LE0)
+
+lemma REAL_NEG_GE0: "real_le (real_of_num 0) (real_neg x) = real_le x (real_of_num 0)"
+  by (import hollight REAL_NEG_GE0)
+
+lemma REAL_LT_TOTAL: "x = y | real_lt x y | real_lt y x"
+  by (import hollight REAL_LT_TOTAL)
+
+lemma REAL_LT_NEGTOTAL: "x = real_of_num 0 |
+real_lt (real_of_num 0) x | real_lt (real_of_num 0) (real_neg x)"
+  by (import hollight REAL_LT_NEGTOTAL)
+
+lemma REAL_LE_01: "real_le (real_of_num 0) (real_of_num 1)"
+  by (import hollight REAL_LE_01)
+
+lemma REAL_LT_01: "real_lt (real_of_num 0) (real_of_num 1)"
+  by (import hollight REAL_LT_01)
+
+lemma REAL_LE_LADD: "real_le (real_add x y) (real_add x z) = real_le y z"
+  by (import hollight REAL_LE_LADD)
+
+lemma REAL_LE_RADD: "real_le (real_add x z) (real_add y z) = real_le x y"
+  by (import hollight REAL_LE_RADD)
+
+lemma REAL_LT_ADD2: "real_lt w x & real_lt y z ==> real_lt (real_add w y) (real_add x z)"
+  by (import hollight REAL_LT_ADD2)
+
+lemma REAL_LE_ADD2: "real_le w x & real_le y z ==> real_le (real_add w y) (real_add x z)"
+  by (import hollight REAL_LE_ADD2)
+
+lemma REAL_LT_LNEG: "real_lt (real_neg x) xa = real_lt (real_of_num 0) (real_add x xa)"
+  by (import hollight REAL_LT_LNEG)
+
+lemma REAL_LT_RNEG: "real_lt x (real_neg xa) = real_lt (real_add x xa) (real_of_num 0)"
+  by (import hollight REAL_LT_RNEG)
+
+lemma REAL_LT_ADDNEG: "real_lt y (real_add x (real_neg z)) = real_lt (real_add y z) x"
+  by (import hollight REAL_LT_ADDNEG)
+
+lemma REAL_LT_ADDNEG2: "real_lt (real_add x (real_neg y)) z = real_lt x (real_add z y)"
+  by (import hollight REAL_LT_ADDNEG2)
+
+lemma REAL_LT_ADD1: "real_le x y ==> real_lt x (real_add y (real_of_num 1))"
+  by (import hollight REAL_LT_ADD1)
+
+lemma REAL_SUB_ADD: "real_add (real_sub x y) y = x"
+  by (import hollight REAL_SUB_ADD)
+
+lemma REAL_SUB_ADD2: "real_add y (real_sub x y) = x"
+  by (import hollight REAL_SUB_ADD2)
+
+lemma REAL_SUB_REFL: "real_sub x x = real_of_num 0"
+  by (import hollight REAL_SUB_REFL)
+
+lemma REAL_LE_DOUBLE: "real_le (real_of_num 0) (real_add x x) = real_le (real_of_num 0) x"
+  by (import hollight REAL_LE_DOUBLE)
+
+lemma REAL_LE_NEGL: "real_le (real_neg x) x = real_le (real_of_num 0) x"
+  by (import hollight REAL_LE_NEGL)
+
+lemma REAL_LE_NEGR: "real_le x (real_neg x) = real_le x (real_of_num 0)"
+  by (import hollight REAL_LE_NEGR)
+
+lemma REAL_NEG_EQ_0: "(real_neg x = real_of_num 0) = (x = real_of_num 0)"
+  by (import hollight REAL_NEG_EQ_0)
+
+lemma REAL_ADD_SUB: "real_sub (real_add x y) x = y"
+  by (import hollight REAL_ADD_SUB)
+
+lemma REAL_NEG_EQ: "(real_neg x = y) = (x = real_neg y)"
+  by (import hollight REAL_NEG_EQ)
+
+lemma REAL_NEG_MINUS1: "real_neg x = real_mul (real_neg (real_of_num 1)) x"
+  by (import hollight REAL_NEG_MINUS1)
+
+lemma REAL_LT_IMP_NE: "real_lt x y ==> x ~= y"
+  by (import hollight REAL_LT_IMP_NE)
+
+lemma REAL_LE_ADDR: "real_le x (real_add x y) = real_le (real_of_num 0) y"
+  by (import hollight REAL_LE_ADDR)
+
+lemma REAL_LE_ADDL: "real_le y (real_add x y) = real_le (real_of_num 0) x"
+  by (import hollight REAL_LE_ADDL)
+
+lemma REAL_LT_ADDR: "real_lt x (real_add x y) = real_lt (real_of_num 0) y"
+  by (import hollight REAL_LT_ADDR)
+
+lemma REAL_LT_ADDL: "real_lt y (real_add x y) = real_lt (real_of_num 0) x"
+  by (import hollight REAL_LT_ADDL)
+
+lemma REAL_SUB_SUB: "real_sub (real_sub x y) x = real_neg y"
+  by (import hollight REAL_SUB_SUB)
+
+lemma REAL_LT_ADD_SUB: "real_lt (real_add x y) z = real_lt x (real_sub z y)"
+  by (import hollight REAL_LT_ADD_SUB)
+
+lemma REAL_LT_SUB_RADD: "real_lt (real_sub x y) z = real_lt x (real_add z y)"
+  by (import hollight REAL_LT_SUB_RADD)
+
+lemma REAL_LT_SUB_LADD: "real_lt x (real_sub y z) = real_lt (real_add x z) y"
+  by (import hollight REAL_LT_SUB_LADD)
+
+lemma REAL_LE_SUB_LADD: "real_le x (real_sub y z) = real_le (real_add x z) y"
+  by (import hollight REAL_LE_SUB_LADD)
+
+lemma REAL_LE_SUB_RADD: "real_le (real_sub x y) z = real_le x (real_add z y)"
+  by (import hollight REAL_LE_SUB_RADD)
+
+lemma REAL_LT_NEG: "real_lt (real_neg x) (real_neg y) = real_lt y x"
+  by (import hollight REAL_LT_NEG)
+
+lemma REAL_LE_NEG: "real_le (real_neg x) (real_neg y) = real_le y x"
+  by (import hollight REAL_LE_NEG)
+
+lemma REAL_ADD2_SUB2: "real_sub (real_add a b) (real_add c d) =
+real_add (real_sub a c) (real_sub b d)"
+  by (import hollight REAL_ADD2_SUB2)
+
+lemma REAL_SUB_LZERO: "real_sub (real_of_num 0) x = real_neg x"
+  by (import hollight REAL_SUB_LZERO)
+
+lemma REAL_SUB_RZERO: "real_sub x (real_of_num 0) = x"
+  by (import hollight REAL_SUB_RZERO)
+
+lemma REAL_LET_ADD2: "real_le w x & real_lt y z ==> real_lt (real_add w y) (real_add x z)"
+  by (import hollight REAL_LET_ADD2)
+
+lemma REAL_LTE_ADD2: "real_lt w x & real_le y z ==> real_lt (real_add w y) (real_add x z)"
+  by (import hollight REAL_LTE_ADD2)
+
+lemma REAL_SUB_LNEG: "real_sub (real_neg x) y = real_neg (real_add x y)"
+  by (import hollight REAL_SUB_LNEG)
+
+lemma REAL_SUB_RNEG: "real_sub x (real_neg y) = real_add x y"
+  by (import hollight REAL_SUB_RNEG)
+
+lemma REAL_SUB_NEG2: "real_sub (real_neg x) (real_neg y) = real_sub y x"
+  by (import hollight REAL_SUB_NEG2)
+
+lemma REAL_SUB_TRIANGLE: "real_add (real_sub a b) (real_sub b c) = real_sub a c"
+  by (import hollight REAL_SUB_TRIANGLE)
+
+lemma REAL_EQ_SUB_LADD: "(x = real_sub y z) = (real_add x z = y)"
+  by (import hollight REAL_EQ_SUB_LADD)
+
+lemma REAL_EQ_SUB_RADD: "(real_sub x y = z) = (x = real_add z y)"
+  by (import hollight REAL_EQ_SUB_RADD)
+
+lemma REAL_SUB_SUB2: "real_sub x (real_sub x y) = y"
+  by (import hollight REAL_SUB_SUB2)
+
+lemma REAL_ADD_SUB2: "real_sub x (real_add x y) = real_neg y"
+  by (import hollight REAL_ADD_SUB2)
+
+lemma REAL_EQ_IMP_LE: "x = y ==> real_le x y"
+  by (import hollight REAL_EQ_IMP_LE)
+
+lemma REAL_POS_NZ: "real_lt (real_of_num 0) x ==> x ~= real_of_num 0"
+  by (import hollight REAL_POS_NZ)
+
+lemma REAL_DIFFSQ: "real_mul (real_add x y) (real_sub x y) =
+real_sub (real_mul x x) (real_mul y y)"
+  by (import hollight REAL_DIFFSQ)
+
+lemma REAL_EQ_NEG2: "(real_neg x = real_neg y) = (x = y)"
+  by (import hollight REAL_EQ_NEG2)
+
+lemma REAL_LT_NEG2: "real_lt (real_neg x) (real_neg y) = real_lt y x"
+  by (import hollight REAL_LT_NEG2)
+
+lemma REAL_SUB_LDISTRIB: "real_mul x (real_sub y z) = real_sub (real_mul x y) (real_mul x z)"
+  by (import hollight REAL_SUB_LDISTRIB)
+
+lemma REAL_SUB_RDISTRIB: "real_mul (real_sub x y) z = real_sub (real_mul x z) (real_mul y z)"
+  by (import hollight REAL_SUB_RDISTRIB)
+
+lemma REAL_ABS_ZERO: "(real_abs x = real_of_num 0) = (x = real_of_num 0)"
+  by (import hollight REAL_ABS_ZERO)
+
+lemma REAL_ABS_0: "real_abs (real_of_num 0) = real_of_num 0"
+  by (import hollight REAL_ABS_0)
+
+lemma REAL_ABS_1: "real_abs (real_of_num 1) = real_of_num 1"
+  by (import hollight REAL_ABS_1)
+
+lemma REAL_ABS_TRIANGLE: "real_le (real_abs (real_add x y)) (real_add (real_abs x) (real_abs y))"
+  by (import hollight REAL_ABS_TRIANGLE)
+
+lemma REAL_ABS_TRIANGLE_LE: "real_le (real_add (real_abs x) (real_abs (real_sub y x))) z
+==> real_le (real_abs y) z"
+  by (import hollight REAL_ABS_TRIANGLE_LE)
+
+lemma REAL_ABS_TRIANGLE_LT: "real_lt (real_add (real_abs x) (real_abs (real_sub y x))) z
+==> real_lt (real_abs y) z"
+  by (import hollight REAL_ABS_TRIANGLE_LT)
+
+lemma REAL_ABS_POS: "real_le (real_of_num 0) (real_abs x)"
+  by (import hollight REAL_ABS_POS)
+
+lemma REAL_ABS_SUB: "real_abs (real_sub x y) = real_abs (real_sub y x)"
+  by (import hollight REAL_ABS_SUB)
+
+lemma REAL_ABS_NZ: "(x ~= real_of_num 0) = real_lt (real_of_num 0) (real_abs x)"
+  by (import hollight REAL_ABS_NZ)
+
+lemma REAL_ABS_ABS: "real_abs (real_abs x) = real_abs x"
+  by (import hollight REAL_ABS_ABS)
+
+lemma REAL_ABS_LE: "real_le x (real_abs x)"
+  by (import hollight REAL_ABS_LE)
+
+lemma REAL_ABS_REFL: "(real_abs x = x) = real_le (real_of_num 0) x"
+  by (import hollight REAL_ABS_REFL)
+
+lemma REAL_ABS_BETWEEN: "(real_lt (real_of_num 0) d &
+ real_lt (real_sub x d) y & real_lt y (real_add x d)) =
+real_lt (real_abs (real_sub y x)) d"
+  by (import hollight REAL_ABS_BETWEEN)
+
+lemma REAL_ABS_BOUND: "real_lt (real_abs (real_sub x y)) d ==> real_lt y (real_add x d)"
+  by (import hollight REAL_ABS_BOUND)
+
+lemma REAL_ABS_STILLNZ: "real_lt (real_abs (real_sub x y)) (real_abs y) ==> x ~= real_of_num 0"
+  by (import hollight REAL_ABS_STILLNZ)
+
+lemma REAL_ABS_CASES: "x = real_of_num 0 | real_lt (real_of_num 0) (real_abs x)"
+  by (import hollight REAL_ABS_CASES)
+
+lemma REAL_ABS_BETWEEN1: "real_lt x z & real_lt (real_abs (real_sub y x)) (real_sub z x)
+==> real_lt y z"
+  by (import hollight REAL_ABS_BETWEEN1)
+
+lemma REAL_ABS_SIGN: "real_lt (real_abs (real_sub x y)) y ==> real_lt (real_of_num 0) x"
+  by (import hollight REAL_ABS_SIGN)
+
+lemma REAL_ABS_SIGN2: "real_lt (real_abs (real_sub x y)) (real_neg y) ==> real_lt x (real_of_num 0)"
+  by (import hollight REAL_ABS_SIGN2)
+
+lemma REAL_ABS_CIRCLE: "real_lt (real_abs h) (real_sub (real_abs y) (real_abs x))
+==> real_lt (real_abs (real_add x h)) (real_abs y)"
+  by (import hollight REAL_ABS_CIRCLE)
+
+lemma REAL_SUB_ABS: "real_le (real_sub (real_abs x) (real_abs y)) (real_abs (real_sub x y))"
+  by (import hollight REAL_SUB_ABS)
+
+lemma REAL_ABS_SUB_ABS: "real_le (real_abs (real_sub (real_abs x) (real_abs y)))
+ (real_abs (real_sub x y))"
+  by (import hollight REAL_ABS_SUB_ABS)
+
+lemma REAL_ABS_BETWEEN2: "real_lt x0 y0 &
+real_lt (real_mul (real_of_num 2) (real_abs (real_sub x x0)))
+ (real_sub y0 x0) &
+real_lt (real_mul (real_of_num 2) (real_abs (real_sub y y0)))
+ (real_sub y0 x0)
+==> real_lt x y"
+  by (import hollight REAL_ABS_BETWEEN2)
+
+lemma REAL_ABS_BOUNDS: "real_le (real_abs x) k = (real_le (real_neg k) x & real_le x k)"
+  by (import hollight REAL_ABS_BOUNDS)
+
+lemma REAL_BOUNDS_LE: "(real_le (real_neg k) x & real_le x k) = real_le (real_abs x) k"
+  by (import hollight REAL_BOUNDS_LE)
+
+lemma REAL_BOUNDS_LT: "(real_lt (real_neg k) x & real_lt x k) = real_lt (real_abs x) k"
+  by (import hollight REAL_BOUNDS_LT)
+
+lemma REAL_MIN_MAX: "real_min x y = real_neg (real_max (real_neg x) (real_neg y))"
+  by (import hollight REAL_MIN_MAX)
+
+lemma REAL_MAX_MIN: "real_max x y = real_neg (real_min (real_neg x) (real_neg y))"
+  by (import hollight REAL_MAX_MIN)
+
+lemma REAL_MAX_MAX: "real_le x (real_max x y) & real_le y (real_max x y)"
+  by (import hollight REAL_MAX_MAX)
+
+lemma REAL_MIN_MIN: "real_le (real_min x y) x & real_le (real_min x y) y"
+  by (import hollight REAL_MIN_MIN)
+
+lemma REAL_MAX_SYM: "real_max x y = real_max y x"
+  by (import hollight REAL_MAX_SYM)
+
+lemma REAL_MIN_SYM: "real_min x y = real_min y x"
+  by (import hollight REAL_MIN_SYM)
+
+lemma REAL_LE_MAX: "real_le z (real_max x y) = (real_le z x | real_le z y)"
+  by (import hollight REAL_LE_MAX)
+
+lemma REAL_LE_MIN: "real_le z (real_min x y) = (real_le z x & real_le z y)"
+  by (import hollight REAL_LE_MIN)
+
+lemma REAL_LT_MAX: "real_lt z (real_max x y) = (real_lt z x | real_lt z y)"
+  by (import hollight REAL_LT_MAX)
+
+lemma REAL_LT_MIN: "real_lt z (real_min x y) = (real_lt z x & real_lt z y)"
+  by (import hollight REAL_LT_MIN)
+
+lemma REAL_MAX_LE: "real_le (real_max x y) z = (real_le x z & real_le y z)"
+  by (import hollight REAL_MAX_LE)
+
+lemma REAL_MIN_LE: "real_le (real_min x y) z = (real_le x z | real_le y z)"
+  by (import hollight REAL_MIN_LE)
+
+lemma REAL_MAX_LT: "real_lt (real_max x y) z = (real_lt x z & real_lt y z)"
+  by (import hollight REAL_MAX_LT)
+
+lemma REAL_MIN_LT: "real_lt (real_min x y) z = (real_lt x z | real_lt y z)"
+  by (import hollight REAL_MIN_LT)
+
+lemma REAL_MAX_ASSOC: "real_max x (real_max y z) = real_max (real_max x y) z"
+  by (import hollight REAL_MAX_ASSOC)
+
+lemma REAL_MIN_ASSOC: "real_min x (real_min y z) = real_min (real_min x y) z"
+  by (import hollight REAL_MIN_ASSOC)
+
+lemma REAL_MAX_ACI: "real_max x y = real_max y x &
+real_max (real_max x y) z = real_max x (real_max y z) &
+real_max x (real_max y z) = real_max y (real_max x z) &
+real_max x x = x & real_max x (real_max x y) = real_max x y"
+  by (import hollight REAL_MAX_ACI)
+
+lemma REAL_MIN_ACI: "real_min x y = real_min y x &
+real_min (real_min x y) z = real_min x (real_min y z) &
+real_min x (real_min y z) = real_min y (real_min x z) &
+real_min x x = x & real_min x (real_min x y) = real_min x y"
+  by (import hollight REAL_MIN_ACI)
+
+lemma REAL_ABS_MUL: "real_abs (real_mul x y) = real_mul (real_abs x) (real_abs y)"
+  by (import hollight REAL_ABS_MUL)
+
+lemma REAL_POW_LE: "real_le (real_of_num 0) x ==> real_le (real_of_num 0) (real_pow x n)"
+  by (import hollight REAL_POW_LE)
+
+lemma REAL_POW_LT: "real_lt (real_of_num 0) x ==> real_lt (real_of_num 0) (real_pow x n)"
+  by (import hollight REAL_POW_LT)
+
+lemma REAL_ABS_POW: "real_abs (real_pow x n) = real_pow (real_abs x) n"
+  by (import hollight REAL_ABS_POW)
+
+lemma REAL_LE_LMUL: "real_le (real_of_num 0) x & real_le xa xb
+==> real_le (real_mul x xa) (real_mul x xb)"
+  by (import hollight REAL_LE_LMUL)
+
+lemma REAL_LE_RMUL: "real_le x y & real_le (real_of_num 0) z
+==> real_le (real_mul x z) (real_mul y z)"
+  by (import hollight REAL_LE_RMUL)
+
+lemma REAL_LT_LMUL: "real_lt (real_of_num 0) x & real_lt xa xb
+==> real_lt (real_mul x xa) (real_mul x xb)"
+  by (import hollight REAL_LT_LMUL)
+
+lemma REAL_LT_RMUL: "real_lt x y & real_lt (real_of_num 0) z
+==> real_lt (real_mul x z) (real_mul y z)"
+  by (import hollight REAL_LT_RMUL)
+
+lemma REAL_EQ_MUL_LCANCEL: "(real_mul x y = real_mul x z) = (x = real_of_num 0 | y = z)"
+  by (import hollight REAL_EQ_MUL_LCANCEL)
+
+lemma REAL_EQ_MUL_RCANCEL: "(real_mul x xb = real_mul xa xb) = (x = xa | xb = real_of_num 0)"
+  by (import hollight REAL_EQ_MUL_RCANCEL)
+
+lemma REAL_MUL_LINV_UNIQ: "real_mul x y = real_of_num 1 ==> real_inv y = x"
+  by (import hollight REAL_MUL_LINV_UNIQ)
+
+lemma REAL_MUL_RINV_UNIQ: "real_mul x xa = real_of_num 1 ==> real_inv x = xa"
+  by (import hollight REAL_MUL_RINV_UNIQ)
+
+lemma REAL_INV_INV: "real_inv (real_inv x) = x"
+  by (import hollight REAL_INV_INV)
+
+lemma REAL_EQ_INV2: "(real_inv x = real_inv y) = (x = y)"
+  by (import hollight REAL_EQ_INV2)
+
+lemma REAL_INV_EQ_0: "(real_inv x = real_of_num 0) = (x = real_of_num 0)"
+  by (import hollight REAL_INV_EQ_0)
+
+lemma REAL_LT_INV: "real_lt (real_of_num 0) x ==> real_lt (real_of_num 0) (real_inv x)"
+  by (import hollight REAL_LT_INV)
+
+lemma REAL_LT_INV_EQ: "real_lt (real_of_num 0) (real_inv x) = real_lt (real_of_num 0) x"
+  by (import hollight REAL_LT_INV_EQ)
+
+lemma REAL_INV_NEG: "real_inv (real_neg x) = real_neg (real_inv x)"
+  by (import hollight REAL_INV_NEG)
+
+lemma REAL_LE_INV_EQ: "real_le (real_of_num 0) (real_inv x) = real_le (real_of_num 0) x"
+  by (import hollight REAL_LE_INV_EQ)
+
+lemma REAL_LE_INV: "real_le (real_of_num 0) x ==> real_le (real_of_num 0) (real_inv x)"
+  by (import hollight REAL_LE_INV)
+
+lemma REAL_MUL_RINV: "x ~= real_of_num 0 ==> real_mul x (real_inv x) = real_of_num 1"
+  by (import hollight REAL_MUL_RINV)
+
+lemma REAL_INV_1: "real_inv (real_of_num 1) = real_of_num 1"
+  by (import hollight REAL_INV_1)
+
+lemma REAL_INV_EQ_1: "(real_inv x = real_of_num 1) = (x = real_of_num 1)"
+  by (import hollight REAL_INV_EQ_1)
+
+lemma REAL_DIV_1: "real_div x (real_of_num 1) = x"
+  by (import hollight REAL_DIV_1)
+
+lemma REAL_DIV_REFL: "x ~= real_of_num 0 ==> real_div x x = real_of_num 1"
+  by (import hollight REAL_DIV_REFL)
+
+lemma REAL_DIV_RMUL: "xa ~= real_of_num 0 ==> real_mul (real_div x xa) xa = x"
+  by (import hollight REAL_DIV_RMUL)
+
+lemma REAL_DIV_LMUL: "xa ~= real_of_num 0 ==> real_mul xa (real_div x xa) = x"
+  by (import hollight REAL_DIV_LMUL)
+
+lemma REAL_ABS_INV: "real_abs (real_inv x) = real_inv (real_abs x)"
+  by (import hollight REAL_ABS_INV)
+
+lemma REAL_ABS_DIV: "real_abs (real_div x xa) = real_div (real_abs x) (real_abs xa)"
+  by (import hollight REAL_ABS_DIV)
+
+lemma REAL_INV_MUL: "real_inv (real_mul x y) = real_mul (real_inv x) (real_inv y)"
+  by (import hollight REAL_INV_MUL)
+
+lemma REAL_INV_DIV: "real_inv (real_div x xa) = real_div xa x"
+  by (import hollight REAL_INV_DIV)
+
+lemma REAL_POW_MUL: "real_pow (real_mul x y) n = real_mul (real_pow x n) (real_pow y n)"
+  by (import hollight REAL_POW_MUL)
+
+lemma REAL_POW_INV: "real_pow (real_inv x) n = real_inv (real_pow x n)"
+  by (import hollight REAL_POW_INV)
+
+lemma REAL_INV_POW: "real_inv (real_pow x xa) = real_pow (real_inv x) xa"
+  by (import hollight REAL_INV_POW)
+
+lemma REAL_POW_DIV: "real_pow (real_div x xa) xb = real_div (real_pow x xb) (real_pow xa xb)"
+  by (import hollight REAL_POW_DIV)
+
+lemma REAL_POW_ADD: "real_pow x (m + n) = real_mul (real_pow x m) (real_pow x n)"
+  by (import hollight REAL_POW_ADD)
+
+lemma REAL_POW_NZ: "x ~= real_of_num 0 ==> real_pow x n ~= real_of_num 0"
+  by (import hollight REAL_POW_NZ)
+
+lemma REAL_POW_SUB: "x ~= real_of_num 0 & m <= n
+==> real_pow x (n - m) = real_div (real_pow x n) (real_pow x m)"
+  by (import hollight REAL_POW_SUB)
+
+lemma REAL_LT_IMP_NZ: "real_lt (real_of_num 0) x ==> x ~= real_of_num 0"
+  by (import hollight REAL_LT_IMP_NZ)
+
+lemma REAL_LT_LCANCEL_IMP: "real_lt (real_of_num 0) x & real_lt (real_mul x y) (real_mul x z)
+==> real_lt y z"
+  by (import hollight REAL_LT_LCANCEL_IMP)
+
+lemma REAL_LT_RCANCEL_IMP: "real_lt (real_of_num 0) xb & real_lt (real_mul x xb) (real_mul xa xb)
+==> real_lt x xa"
+  by (import hollight REAL_LT_RCANCEL_IMP)
+
+lemma REAL_LE_LCANCEL_IMP: "real_lt (real_of_num 0) x & real_le (real_mul x y) (real_mul x z)
+==> real_le y z"
+  by (import hollight REAL_LE_LCANCEL_IMP)
+
+lemma REAL_LE_RCANCEL_IMP: "real_lt (real_of_num 0) xb & real_le (real_mul x xb) (real_mul xa xb)
+==> real_le x xa"
+  by (import hollight REAL_LE_RCANCEL_IMP)
+
+lemma REAL_LE_RMUL_EQ: "real_lt (real_of_num 0) z
+==> real_le (real_mul x z) (real_mul y z) = real_le x y"
+  by (import hollight REAL_LE_RMUL_EQ)
+
+lemma REAL_LE_LMUL_EQ: "real_lt (real_of_num 0) z
+==> real_le (real_mul z x) (real_mul z y) = real_le x y"
+  by (import hollight REAL_LE_LMUL_EQ)
+
+lemma REAL_LT_RMUL_EQ: "real_lt (real_of_num 0) xb
+==> real_lt (real_mul x xb) (real_mul xa xb) = real_lt x xa"
+  by (import hollight REAL_LT_RMUL_EQ)
+
+lemma REAL_LT_LMUL_EQ: "real_lt (real_of_num 0) xb
+==> real_lt (real_mul xb x) (real_mul xb xa) = real_lt x xa"
+  by (import hollight REAL_LT_LMUL_EQ)
+
+lemma REAL_LE_MUL_EQ: "(ALL x y.
+    real_lt (real_of_num 0) x -->
+    real_le (real_of_num 0) (real_mul x y) = real_le (real_of_num 0) y) &
+(ALL x y.
+    real_lt (real_of_num 0) y -->
+    real_le (real_of_num 0) (real_mul x y) = real_le (real_of_num 0) x)"
+  by (import hollight REAL_LE_MUL_EQ)
+
+lemma REAL_LT_MUL_EQ: "(ALL x y.
+    real_lt (real_of_num 0) x -->
+    real_lt (real_of_num 0) (real_mul x y) = real_lt (real_of_num 0) y) &
+(ALL x y.
+    real_lt (real_of_num 0) y -->
+    real_lt (real_of_num 0) (real_mul x y) = real_lt (real_of_num 0) x)"
+  by (import hollight REAL_LT_MUL_EQ)
+
+lemma REAL_MUL_POS_LT: "real_lt (real_of_num 0) (real_mul x y) =
+(real_lt (real_of_num 0) x & real_lt (real_of_num 0) y |
+ real_lt x (real_of_num 0) & real_lt y (real_of_num 0))"
+  by (import hollight REAL_MUL_POS_LT)
+
+lemma REAL_MUL_POS_LE: "real_le (real_of_num 0) (real_mul x xa) =
+(x = real_of_num 0 |
+ xa = real_of_num 0 |
+ real_lt (real_of_num 0) x & real_lt (real_of_num 0) xa |
+ real_lt x (real_of_num 0) & real_lt xa (real_of_num 0))"
+  by (import hollight REAL_MUL_POS_LE)
+
+lemma REAL_LE_RDIV_EQ: "real_lt (real_of_num 0) z
+==> real_le x (real_div y z) = real_le (real_mul x z) y"
+  by (import hollight REAL_LE_RDIV_EQ)
+
+lemma REAL_LE_LDIV_EQ: "real_lt (real_of_num 0) z
+==> real_le (real_div x z) y = real_le x (real_mul y z)"
+  by (import hollight REAL_LE_LDIV_EQ)
+
+lemma REAL_LT_RDIV_EQ: "real_lt (real_of_num 0) xb
+==> real_lt x (real_div xa xb) = real_lt (real_mul x xb) xa"
+  by (import hollight REAL_LT_RDIV_EQ)
+
+lemma REAL_LT_LDIV_EQ: "real_lt (real_of_num 0) xb
+==> real_lt (real_div x xb) xa = real_lt x (real_mul xa xb)"
+  by (import hollight REAL_LT_LDIV_EQ)
+
+lemma REAL_EQ_RDIV_EQ: "real_lt (real_of_num 0) xb ==> (x = real_div xa xb) = (real_mul x xb = xa)"
+  by (import hollight REAL_EQ_RDIV_EQ)
+
+lemma REAL_EQ_LDIV_EQ: "real_lt (real_of_num 0) xb ==> (real_div x xb = xa) = (x = real_mul xa xb)"
+  by (import hollight REAL_EQ_LDIV_EQ)
+
+lemma REAL_LT_DIV2_EQ: "real_lt (real_of_num 0) xb
+==> real_lt (real_div x xb) (real_div xa xb) = real_lt x xa"
+  by (import hollight REAL_LT_DIV2_EQ)
+
+lemma REAL_LE_DIV2_EQ: "real_lt (real_of_num 0) xb
+==> real_le (real_div x xb) (real_div xa xb) = real_le x xa"
+  by (import hollight REAL_LE_DIV2_EQ)
+
+lemma REAL_MUL_2: "real_mul (real_of_num 2) x = real_add x x"
+  by (import hollight REAL_MUL_2)
+
+lemma REAL_POW_EQ_0: "(real_pow x n = real_of_num 0) = (x = real_of_num 0 & n ~= 0)"
+  by (import hollight REAL_POW_EQ_0)
+
+lemma REAL_LE_MUL2: "real_le (real_of_num 0) w &
+real_le w x & real_le (real_of_num 0) y & real_le y z
+==> real_le (real_mul w y) (real_mul x z)"
+  by (import hollight REAL_LE_MUL2)
+
+lemma REAL_LT_MUL2: "real_le (real_of_num 0) w &
+real_lt w x & real_le (real_of_num 0) y & real_lt y z
+==> real_lt (real_mul w y) (real_mul x z)"
+  by (import hollight REAL_LT_MUL2)
+
+lemma REAL_LT_SQUARE: "real_lt (real_of_num 0) (real_mul x x) = (x ~= real_of_num 0)"
+  by (import hollight REAL_LT_SQUARE)
+
+lemma REAL_POW_1: "real_pow x 1 = x"
+  by (import hollight REAL_POW_1)
+
+lemma REAL_POW_ONE: "real_pow (real_of_num 1) n = real_of_num 1"
+  by (import hollight REAL_POW_ONE)
+
+lemma REAL_LT_INV2: "real_lt (real_of_num 0) x & real_lt x y
+==> real_lt (real_inv y) (real_inv x)"
+  by (import hollight REAL_LT_INV2)
+
+lemma REAL_LE_INV2: "real_lt (real_of_num 0) x & real_le x y
+==> real_le (real_inv y) (real_inv x)"
+  by (import hollight REAL_LE_INV2)
+
+lemma REAL_LT_LINV: "real_lt (real_of_num 0) y & real_lt (real_inv y) x
+==> real_lt (real_inv x) y"
+  by (import hollight REAL_LT_LINV)
+
+lemma REAL_LT_RINV: "real_lt (real_of_num 0) x & real_lt x (real_inv y)
+==> real_lt y (real_inv x)"
+  by (import hollight REAL_LT_RINV)
+
+lemma REAL_LE_LINV: "real_lt (real_of_num 0) y & real_le (real_inv y) x
+==> real_le (real_inv x) y"
+  by (import hollight REAL_LE_LINV)
+
+lemma REAL_LE_RINV: "real_lt (real_of_num 0) x & real_le x (real_inv y)
+==> real_le y (real_inv x)"
+  by (import hollight REAL_LE_RINV)
+
+lemma REAL_INV_LE_1: "real_le (real_of_num 1) x ==> real_le (real_inv x) (real_of_num 1)"
+  by (import hollight REAL_INV_LE_1)
+
+lemma REAL_INV_1_LE: "real_lt (real_of_num 0) x & real_le x (real_of_num 1)
+==> real_le (real_of_num 1) (real_inv x)"
+  by (import hollight REAL_INV_1_LE)
+
+lemma REAL_INV_LT_1: "real_lt (real_of_num 1) x ==> real_lt (real_inv x) (real_of_num 1)"
+  by (import hollight REAL_INV_LT_1)
+
+lemma REAL_INV_1_LT: "real_lt (real_of_num 0) x & real_lt x (real_of_num 1)
+==> real_lt (real_of_num 1) (real_inv x)"
+  by (import hollight REAL_INV_1_LT)
+
+lemma REAL_SUB_INV: "x ~= real_of_num 0 & xa ~= real_of_num 0
+==> real_sub (real_inv x) (real_inv xa) =
+    real_div (real_sub xa x) (real_mul x xa)"
+  by (import hollight REAL_SUB_INV)
+
+lemma REAL_DOWN: "real_lt (real_of_num 0) d ==> EX x. real_lt (real_of_num 0) x & real_lt x d"
+  by (import hollight REAL_DOWN)
+
+lemma REAL_DOWN2: "real_lt (real_of_num 0) d1 & real_lt (real_of_num 0) d2
+==> EX e. real_lt (real_of_num 0) e & real_lt e d1 & real_lt e d2"
+  by (import hollight REAL_DOWN2)
+
+lemma REAL_POW_LE2: "real_le (real_of_num 0) x & real_le x y
+==> real_le (real_pow x n) (real_pow y n)"
+  by (import hollight REAL_POW_LE2)
+
+lemma REAL_POW_LE_1: "real_le (real_of_num 1) x ==> real_le (real_of_num 1) (real_pow x n)"
+  by (import hollight REAL_POW_LE_1)
+
+lemma REAL_POW_1_LE: "real_le (real_of_num 0) x & real_le x (real_of_num 1)
+==> real_le (real_pow x n) (real_of_num 1)"
+  by (import hollight REAL_POW_1_LE)
+
+lemma REAL_POW_MONO: "real_le (real_of_num 1) x & m <= n ==> real_le (real_pow x m) (real_pow x n)"
+  by (import hollight REAL_POW_MONO)
+
+lemma REAL_POW_LT2: "n ~= 0 & real_le (real_of_num 0) x & real_lt x y
+==> real_lt (real_pow x n) (real_pow y n)"
+  by (import hollight REAL_POW_LT2)
+
+lemma REAL_POW_LT_1: "n ~= 0 & real_lt (real_of_num 1) x
+==> real_lt (real_of_num 1) (real_pow x n)"
+  by (import hollight REAL_POW_LT_1)
+
+lemma REAL_POW_1_LT: "n ~= 0 & real_le (real_of_num 0) x & real_lt x (real_of_num 1)
+==> real_lt (real_pow x n) (real_of_num 1)"
+  by (import hollight REAL_POW_1_LT)
+
+lemma REAL_POW_MONO_LT: "real_lt (real_of_num 1) x & m < n ==> real_lt (real_pow x m) (real_pow x n)"
+  by (import hollight REAL_POW_MONO_LT)
+
+lemma REAL_POW_POW: "real_pow (real_pow x m) n = real_pow x (m * n)"
+  by (import hollight REAL_POW_POW)
+
+lemma REAL_EQ_RCANCEL_IMP: "z ~= real_of_num 0 & real_mul x z = real_mul y z ==> x = y"
+  by (import hollight REAL_EQ_RCANCEL_IMP)
+
+lemma REAL_EQ_LCANCEL_IMP: "xb ~= real_of_num 0 & real_mul xb x = real_mul xb xa ==> x = xa"
+  by (import hollight REAL_EQ_LCANCEL_IMP)
+
+lemma REAL_LT_DIV: "real_lt (real_of_num 0) x & real_lt (real_of_num 0) xa
+==> real_lt (real_of_num 0) (real_div x xa)"
+  by (import hollight REAL_LT_DIV)
+
+lemma REAL_LE_DIV: "real_le (real_of_num 0) x & real_le (real_of_num 0) xa
+==> real_le (real_of_num 0) (real_div x xa)"
+  by (import hollight REAL_LE_DIV)
+
+lemma REAL_DIV_POW2: "x ~= real_of_num 0
+==> real_div (real_pow x m) (real_pow x n) =
+    (if n <= m then real_pow x (m - n) else real_inv (real_pow x (n - m)))"
+  by (import hollight REAL_DIV_POW2)
+
+lemma REAL_DIV_POW2_ALT: "x ~= real_of_num 0
+==> real_div (real_pow x m) (real_pow x n) =
+    (if n < m then real_pow x (m - n) else real_inv (real_pow x (n - m)))"
+  by (import hollight REAL_DIV_POW2_ALT)
+
+lemma REAL_LT_POW2: "real_lt (real_of_num 0) (real_pow (real_of_num 2) x)"
+  by (import hollight REAL_LT_POW2)
+
+lemma REAL_LE_POW2: "real_le (real_of_num 1) (real_pow (real_of_num 2) n)"
+  by (import hollight REAL_LE_POW2)
+
+lemma REAL_POW2_ABS: "real_pow (real_abs x) 2 = real_pow x 2"
+  by (import hollight REAL_POW2_ABS)
+
+lemma REAL_LE_SQUARE_ABS: "real_le (real_abs x) (real_abs y) = real_le (real_pow x 2) (real_pow y 2)"
+  by (import hollight REAL_LE_SQUARE_ABS)
+
+lemma REAL_LT_SQUARE_ABS: "real_lt (real_abs x) (real_abs xa) = real_lt (real_pow x 2) (real_pow xa 2)"
+  by (import hollight REAL_LT_SQUARE_ABS)
+
+lemma REAL_EQ_SQUARE_ABS: "(real_abs x = real_abs xa) = (real_pow x 2 = real_pow xa 2)"
+  by (import hollight REAL_EQ_SQUARE_ABS)
+
+lemma REAL_LE_POW_2: "real_le (real_of_num 0) (real_pow x 2)"
+  by (import hollight REAL_LE_POW_2)
+
+lemma REAL_SOS_EQ_0: "(real_add (real_pow x 2) (real_pow y 2) = real_of_num 0) =
+(x = real_of_num 0 & y = real_of_num 0)"
+  by (import hollight REAL_SOS_EQ_0)
+
+lemma REAL_POW_ZERO: "real_pow (real_of_num 0) n =
+(if n = 0 then real_of_num 1 else real_of_num 0)"
+  by (import hollight REAL_POW_ZERO)
+
+lemma REAL_POW_MONO_INV: "real_le (real_of_num 0) x & real_le x (real_of_num 1) & n <= m
+==> real_le (real_pow x m) (real_pow x n)"
+  by (import hollight REAL_POW_MONO_INV)
+
+lemma REAL_POW_LE2_REV: "n ~= 0 & real_le (real_of_num 0) y & real_le (real_pow x n) (real_pow y n)
+==> real_le x y"
+  by (import hollight REAL_POW_LE2_REV)
+
+lemma REAL_POW_LT2_REV: "real_le (real_of_num 0) y & real_lt (real_pow x n) (real_pow y n)
+==> real_lt x y"
+  by (import hollight REAL_POW_LT2_REV)
+
+lemma REAL_POW_EQ: "x ~= 0 &
+real_le (real_of_num 0) xa &
+real_le (real_of_num 0) xb & real_pow xa x = real_pow xb x
+==> xa = xb"
+  by (import hollight REAL_POW_EQ)
+
+lemma REAL_POW_EQ_ABS: "n ~= 0 & real_pow x n = real_pow y n ==> real_abs x = real_abs y"
+  by (import hollight REAL_POW_EQ_ABS)
+
+lemma REAL_POW_EQ_1_IMP: "n ~= 0 & real_pow x n = real_of_num 1 ==> real_abs x = real_of_num 1"
+  by (import hollight REAL_POW_EQ_1_IMP)
+
+lemma REAL_POW_EQ_1: "(real_pow x n = real_of_num 1) =
+(real_abs x = real_of_num 1 & (real_lt x (real_of_num 0) --> even n) |
+ n = 0)"
+  by (import hollight REAL_POW_EQ_1)
+
+lemma REAL_POW_LT2_ODD: "real_lt x y & odd n ==> real_lt (real_pow x n) (real_pow y n)"
+  by (import hollight REAL_POW_LT2_ODD)
+
+lemma REAL_POW_LE2_ODD: "real_le xa xb & odd x ==> real_le (real_pow xa x) (real_pow xb x)"
+  by (import hollight REAL_POW_LE2_ODD)
+
+lemma REAL_POW_LT2_ODD_EQ: "odd n ==> real_lt (real_pow x n) (real_pow y n) = real_lt x y"
+  by (import hollight REAL_POW_LT2_ODD_EQ)
+
+lemma REAL_POW_LE2_ODD_EQ: "odd n ==> real_le (real_pow x n) (real_pow y n) = real_le x y"
+  by (import hollight REAL_POW_LE2_ODD_EQ)
+
+lemma REAL_POW_EQ_ODD_EQ: "odd x ==> (real_pow xa x = real_pow xb x) = (xa = xb)"
+  by (import hollight REAL_POW_EQ_ODD_EQ)
+
+lemma REAL_POW_EQ_ODD: "odd n & real_pow x n = real_pow y n ==> x = y"
+  by (import hollight REAL_POW_EQ_ODD)
+
+lemma REAL_POW_EQ_EQ: "(real_pow x n = real_pow y n) =
+(if even n then n = 0 | real_abs x = real_abs y else x = y)"
+  by (import hollight REAL_POW_EQ_EQ)
+
+definition
+  real_sgn :: "hollight.real => hollight.real"  where
+  "real_sgn ==
+%u. if real_lt (real_of_num 0) u then real_of_num 1
+    else if real_lt u (real_of_num 0) then real_neg (real_of_num 1)
+         else real_of_num 0"
+
+lemma DEF_real_sgn: "real_sgn =
+(%u. if real_lt (real_of_num 0) u then real_of_num 1
+     else if real_lt u (real_of_num 0) then real_neg (real_of_num 1)
+          else real_of_num 0)"
+  by (import hollight DEF_real_sgn)
+
+lemma REAL_SGN_0: "real_sgn (real_of_num 0) = real_of_num 0"
+  by (import hollight REAL_SGN_0)
+
+lemma REAL_SGN_NEG: "real_sgn (real_neg x) = real_neg (real_sgn x)"
+  by (import hollight REAL_SGN_NEG)
+
+lemma REAL_SGN_ABS: "real_mul (real_sgn x) (real_abs x) = x"
+  by (import hollight REAL_SGN_ABS)
+
+lemma REAL_ABS_SGN: "real_abs (real_sgn x) = real_sgn (real_abs x)"
+  by (import hollight REAL_ABS_SGN)
+
+lemma REAL_SGN: "real_sgn x = real_div x (real_abs x)"
+  by (import hollight REAL_SGN)
+
+lemma REAL_SGN_MUL: "real_sgn (real_mul x xa) = real_mul (real_sgn x) (real_sgn xa)"
+  by (import hollight REAL_SGN_MUL)
+
+lemma REAL_SGN_INV: "real_sgn (real_inv x) = real_sgn x"
+  by (import hollight REAL_SGN_INV)
+
+lemma REAL_SGN_DIV: "real_sgn (real_div x xa) = real_div (real_sgn x) (real_sgn xa)"
+  by (import hollight REAL_SGN_DIV)
+
+lemma REAL_WLOG_LE: "(ALL x y. P x y = P y x) & (ALL x y. real_le x y --> P x y) ==> P x xa"
+  by (import hollight REAL_WLOG_LE)
+
+lemma REAL_WLOG_LT: "(ALL x. P x x) & (ALL x y. P x y = P y x) & (ALL x y. real_lt x y --> P x y)
+==> P x xa"
+  by (import hollight REAL_WLOG_LT)
+
+definition
+  DECIMAL :: "nat => nat => hollight.real"  where
+  "DECIMAL == %u ua. real_div (real_of_num u) (real_of_num ua)"
+
+lemma DEF_DECIMAL: "DECIMAL = (%u ua. real_div (real_of_num u) (real_of_num ua))"
+  by (import hollight DEF_DECIMAL)
+
+lemma RAT_LEMMA1: "y1 ~= real_of_num 0 & y2 ~= real_of_num 0
+==> real_add (real_div x1 y1) (real_div x2 y2) =
+    real_mul (real_add (real_mul x1 y2) (real_mul x2 y1))
+     (real_mul (real_inv y1) (real_inv y2))"
+  by (import hollight RAT_LEMMA1)
+
+lemma RAT_LEMMA2: "real_lt (real_of_num 0) y1 & real_lt (real_of_num 0) y2
+==> real_add (real_div x1 y1) (real_div x2 y2) =
+    real_mul (real_add (real_mul x1 y2) (real_mul x2 y1))
+     (real_mul (real_inv y1) (real_inv y2))"
+  by (import hollight RAT_LEMMA2)
+
+lemma RAT_LEMMA3: "real_lt (real_of_num 0) y1 & real_lt (real_of_num 0) y2
+==> real_sub (real_div x1 y1) (real_div x2 y2) =
+    real_mul (real_sub (real_mul x1 y2) (real_mul x2 y1))
+     (real_mul (real_inv y1) (real_inv y2))"
+  by (import hollight RAT_LEMMA3)
+
+lemma RAT_LEMMA4: "real_lt (real_of_num 0) y1 & real_lt (real_of_num 0) y2
+==> real_le (real_div x1 y1) (real_div x2 y2) =
+    real_le (real_mul x1 y2) (real_mul x2 y1)"
+  by (import hollight RAT_LEMMA4)
+
+lemma RAT_LEMMA5: "real_lt (real_of_num 0) y1 & real_lt (real_of_num 0) y2
+==> (real_div x1 y1 = real_div x2 y2) = (real_mul x1 y2 = real_mul x2 y1)"
+  by (import hollight RAT_LEMMA5)
+
+lemma REAL_INTEGRAL: "(ALL x. real_mul (real_of_num 0) x = real_of_num 0) &
+(ALL x y z. (real_add x y = real_add x z) = (y = z)) &
+(ALL w x y z.
+    (real_add (real_mul w y) (real_mul x z) =
+     real_add (real_mul w z) (real_mul x y)) =
+    (w = x | y = z))"
+  by (import hollight REAL_INTEGRAL)
+
+definition
+  integer :: "hollight.real => bool"  where
+  "integer == %u. EX n. real_abs u = real_of_num n"
+
+lemma DEF_integer: "integer = (%u. EX n. real_abs u = real_of_num n)"
+  by (import hollight DEF_integer)
+
+lemma is_int: "integer x = (EX n. x = real_of_num n | x = real_neg (real_of_num n))"
+  by (import hollight is_int)
+
+typedef (open) int = "Collect integer"  morphisms "real_of_int" "int_of_real"
+  apply (rule light_ex_imp_nonempty[where t="Eps integer"])
+  by (import hollight TYDEF_int)
+
+syntax
+  real_of_int :: _ 
+
+syntax
+  int_of_real :: _ 
+
+lemmas "TYDEF_int_@intern" = typedef_hol2hollight 
+  [where a="a :: hollight.int" and r=r ,
+   OF type_definition_int]
+
+lemma dest_int_rep: "EX n. hollight.real_of_int x = real_of_num n |
+      hollight.real_of_int x = real_neg (real_of_num n)"
+  by (import hollight dest_int_rep)
+
+definition
+  int_le :: "hollight.int => hollight.int => bool"  where
+  "int_le == %u ua. real_le (hollight.real_of_int u) (hollight.real_of_int ua)"
+
+lemma DEF_int_le: "int_le = (%u ua. real_le (hollight.real_of_int u) (hollight.real_of_int ua))"
+  by (import hollight DEF_int_le)
+
+definition
+  int_lt :: "hollight.int => hollight.int => bool"  where
+  "int_lt == %u ua. real_lt (hollight.real_of_int u) (hollight.real_of_int ua)"
+
+lemma DEF_int_lt: "int_lt = (%u ua. real_lt (hollight.real_of_int u) (hollight.real_of_int ua))"
+  by (import hollight DEF_int_lt)
+
+definition
+  int_ge :: "hollight.int => hollight.int => bool"  where
+  "int_ge == %u ua. real_ge (hollight.real_of_int u) (hollight.real_of_int ua)"
+
+lemma DEF_int_ge: "int_ge = (%u ua. real_ge (hollight.real_of_int u) (hollight.real_of_int ua))"
+  by (import hollight DEF_int_ge)
+
+definition
+  int_gt :: "hollight.int => hollight.int => bool"  where
+  "int_gt == %u ua. real_gt (hollight.real_of_int u) (hollight.real_of_int ua)"
+
+lemma DEF_int_gt: "int_gt = (%u ua. real_gt (hollight.real_of_int u) (hollight.real_of_int ua))"
+  by (import hollight DEF_int_gt)
+
+definition
+  int_of_num :: "nat => hollight.int"  where
+  "int_of_num == %u. int_of_real (real_of_num u)"
+
+lemma DEF_int_of_num: "int_of_num = (%u. int_of_real (real_of_num u))"
+  by (import hollight DEF_int_of_num)
+
+lemma int_of_num_th: "hollight.real_of_int (int_of_num x) = real_of_num x"
+  by (import hollight int_of_num_th)
+
+definition
+  int_neg :: "hollight.int => hollight.int"  where
+  "int_neg == %u. int_of_real (real_neg (hollight.real_of_int u))"
+
+lemma DEF_int_neg: "int_neg = (%u. int_of_real (real_neg (hollight.real_of_int u)))"
+  by (import hollight DEF_int_neg)
+
+lemma int_neg_th: "hollight.real_of_int (int_neg x) = real_neg (hollight.real_of_int x)"
+  by (import hollight int_neg_th)
+
+definition
+  int_add :: "hollight.int => hollight.int => hollight.int"  where
+  "int_add ==
+%u ua.
+   int_of_real (real_add (hollight.real_of_int u) (hollight.real_of_int ua))"
+
+lemma DEF_int_add: "int_add =
+(%u ua.
+    int_of_real
+     (real_add (hollight.real_of_int u) (hollight.real_of_int ua)))"
+  by (import hollight DEF_int_add)
+
+lemma int_add_th: "hollight.real_of_int (int_add x xa) =
+real_add (hollight.real_of_int x) (hollight.real_of_int xa)"
+  by (import hollight int_add_th)
+
+definition
+  int_sub :: "hollight.int => hollight.int => hollight.int"  where
+  "int_sub ==
+%u ua.
+   int_of_real (real_sub (hollight.real_of_int u) (hollight.real_of_int ua))"
+
+lemma DEF_int_sub: "int_sub =
+(%u ua.
+    int_of_real
+     (real_sub (hollight.real_of_int u) (hollight.real_of_int ua)))"
+  by (import hollight DEF_int_sub)
+
+lemma int_sub_th: "hollight.real_of_int (int_sub x xa) =
+real_sub (hollight.real_of_int x) (hollight.real_of_int xa)"
+  by (import hollight int_sub_th)
+
+definition
+  int_mul :: "hollight.int => hollight.int => hollight.int"  where
+  "int_mul ==
+%u ua.
+   int_of_real (real_mul (hollight.real_of_int u) (hollight.real_of_int ua))"
+
+lemma DEF_int_mul: "int_mul =
+(%u ua.
+    int_of_real
+     (real_mul (hollight.real_of_int u) (hollight.real_of_int ua)))"
+  by (import hollight DEF_int_mul)
+
+lemma int_mul_th: "hollight.real_of_int (int_mul x y) =
+real_mul (hollight.real_of_int x) (hollight.real_of_int y)"
+  by (import hollight int_mul_th)
+
+definition
+  int_abs :: "hollight.int => hollight.int"  where
+  "int_abs == %u. int_of_real (real_abs (hollight.real_of_int u))"
+
+lemma DEF_int_abs: "int_abs = (%u. int_of_real (real_abs (hollight.real_of_int u)))"
+  by (import hollight DEF_int_abs)
+
+lemma int_abs_th: "hollight.real_of_int (int_abs x) = real_abs (hollight.real_of_int x)"
+  by (import hollight int_abs_th)
+
+definition
+  int_sgn :: "hollight.int => hollight.int"  where
+  "int_sgn == %u. int_of_real (real_sgn (hollight.real_of_int u))"
+
+lemma DEF_int_sgn: "int_sgn = (%u. int_of_real (real_sgn (hollight.real_of_int u)))"
+  by (import hollight DEF_int_sgn)
+
+lemma int_sgn_th: "hollight.real_of_int (int_sgn x) = real_sgn (hollight.real_of_int x)"
+  by (import hollight int_sgn_th)
+
+definition
+  int_max :: "hollight.int => hollight.int => hollight.int"  where
+  "int_max ==
+%u ua.
+   int_of_real (real_max (hollight.real_of_int u) (hollight.real_of_int ua))"
+
+lemma DEF_int_max: "int_max =
+(%u ua.
+    int_of_real
+     (real_max (hollight.real_of_int u) (hollight.real_of_int ua)))"
+  by (import hollight DEF_int_max)
+
+lemma int_max_th: "hollight.real_of_int (int_max x y) =
+real_max (hollight.real_of_int x) (hollight.real_of_int y)"
+  by (import hollight int_max_th)
+
+definition
+  int_min :: "hollight.int => hollight.int => hollight.int"  where
+  "int_min ==
+%u ua.
+   int_of_real (real_min (hollight.real_of_int u) (hollight.real_of_int ua))"
+
+lemma DEF_int_min: "int_min =
+(%u ua.
+    int_of_real
+     (real_min (hollight.real_of_int u) (hollight.real_of_int ua)))"
+  by (import hollight DEF_int_min)
+
+lemma int_min_th: "hollight.real_of_int (int_min x y) =
+real_min (hollight.real_of_int x) (hollight.real_of_int y)"
+  by (import hollight int_min_th)
+
+definition
+  int_pow :: "hollight.int => nat => hollight.int"  where
+  "int_pow == %u ua. int_of_real (real_pow (hollight.real_of_int u) ua)"
+
+lemma DEF_int_pow: "int_pow = (%u ua. int_of_real (real_pow (hollight.real_of_int u) ua))"
+  by (import hollight DEF_int_pow)
+
+lemma int_pow_th: "hollight.real_of_int (int_pow x xa) = real_pow (hollight.real_of_int x) xa"
+  by (import hollight int_pow_th)
+
+lemma INT_IMAGE: "(EX n. x = int_of_num n) | (EX n. x = int_neg (int_of_num n))"
+  by (import hollight INT_IMAGE)
+
+lemma INT_LT_DISCRETE: "int_lt x y = int_le (int_add x (int_of_num 1)) y"
+  by (import hollight INT_LT_DISCRETE)
+
+lemma INT_GT_DISCRETE: "int_gt x xa = int_ge x (int_add xa (int_of_num 1))"
+  by (import hollight INT_GT_DISCRETE)
+
+lemma INT_FORALL_POS: "(ALL n. P (int_of_num n)) = (ALL i. int_le (int_of_num 0) i --> P i)"
+  by (import hollight INT_FORALL_POS)
+
+lemma INT_EXISTS_POS: "(EX n. P (int_of_num n)) = (EX i. int_le (int_of_num 0) i & P i)"
+  by (import hollight INT_EXISTS_POS)
+
+lemma INT_FORALL_ABS: "(ALL n. x (int_of_num n)) = (ALL xa. x (int_abs xa))"
+  by (import hollight INT_FORALL_ABS)
+
+lemma INT_EXISTS_ABS: "(EX n. P (int_of_num n)) = (EX x. P (int_abs x))"
+  by (import hollight INT_EXISTS_ABS)
+
+lemma INT_ABS_MUL_1: "(int_abs (int_mul x y) = int_of_num 1) =
+(int_abs x = int_of_num 1 & int_abs y = int_of_num 1)"
+  by (import hollight INT_ABS_MUL_1)
+
+lemma INT_WOP: "(EX x. int_le (int_of_num 0) x & P x) =
+(EX x. int_le (int_of_num 0) x &
+       P x & (ALL y. int_le (int_of_num 0) y & P y --> int_le x y))"
+  by (import hollight INT_WOP)
+
+lemma INT_POW: "int_pow x 0 = int_of_num 1 &
+(ALL xa. int_pow x (Suc xa) = int_mul x (int_pow x xa))"
+  by (import hollight INT_POW)
+
+lemma INT_ABS: "int_abs x = (if int_le (int_of_num 0) x then x else int_neg x)"
+  by (import hollight INT_ABS)
+
+lemma INT_GE: "int_ge x xa = int_le xa x"
+  by (import hollight INT_GE)
+
+lemma INT_GT: "int_gt x xa = int_lt xa x"
+  by (import hollight INT_GT)
+
+lemma INT_LT: "int_lt x xa = (~ int_le xa x)"
+  by (import hollight INT_LT)
+
+lemma INT_ARCH: "d ~= int_of_num 0 ==> EX c. int_lt x (int_mul c d)"
+  by (import hollight INT_ARCH)
+
+lemma INT_DIVMOD_EXIST_0: "EX x xa.
+   if n = int_of_num 0 then x = int_of_num 0 & xa = m
+   else int_le (int_of_num 0) xa &
+        int_lt xa (int_abs n) & m = int_add (int_mul x n) xa"
+  by (import hollight INT_DIVMOD_EXIST_0)
+
+consts
+  div :: "hollight.int => hollight.int => hollight.int" ("div")
+
+defs
+  div_def: "div ==
+SOME q.
+   EX r. ALL m n.
+            if n = int_of_num 0 then q m n = int_of_num 0 & r m n = m
+            else int_le (int_of_num 0) (r m n) &
+                 int_lt (r m n) (int_abs n) &
+                 m = int_add (int_mul (q m n) n) (r m n)"
+
+lemma DEF_div: "div =
+(SOME q.
+    EX r. ALL m n.
+             if n = int_of_num 0 then q m n = int_of_num 0 & r m n = m
+             else int_le (int_of_num 0) (r m n) &
+                  int_lt (r m n) (int_abs n) &
+                  m = int_add (int_mul (q m n) n) (r m n))"
+  by (import hollight DEF_div)
+
+definition
+  rem :: "hollight.int => hollight.int => hollight.int"  where
+  "rem ==
+SOME r.
+   ALL m n.
+      if n = int_of_num 0 then div m n = int_of_num 0 & r m n = m
+      else int_le (int_of_num 0) (r m n) &
+           int_lt (r m n) (int_abs n) &
+           m = int_add (int_mul (div m n) n) (r m n)"
+
+lemma DEF_rem: "rem =
+(SOME r.
+    ALL m n.
+       if n = int_of_num 0 then div m n = int_of_num 0 & r m n = m
+       else int_le (int_of_num 0) (r m n) &
+            int_lt (r m n) (int_abs n) &
+            m = int_add (int_mul (div m n) n) (r m n))"
+  by (import hollight DEF_rem)
+
+lemma INT_DIVISION: "n ~= int_of_num 0
+==> m = int_add (int_mul (div m n) n) (rem m n) &
+    int_le (int_of_num 0) (rem m n) & int_lt (rem m n) (int_abs n)"
+  by (import hollight INT_DIVISION)
+
+lemma sth: "(ALL x y z. int_add x (int_add y z) = int_add (int_add x y) z) &
+(ALL x y. int_add x y = int_add y x) &
+(ALL x. int_add (int_of_num 0) x = x) &
+(ALL x y z. int_mul x (int_mul y z) = int_mul (int_mul x y) z) &
+(ALL x y. int_mul x y = int_mul y x) &
+(ALL x. int_mul (int_of_num 1) x = x) &
+(ALL x. int_mul (int_of_num 0) x = int_of_num 0) &
+(ALL x y z. int_mul x (int_add y z) = int_add (int_mul x y) (int_mul x z)) &
+(ALL x. int_pow x 0 = int_of_num 1) &
+(ALL x xa. int_pow x (Suc xa) = int_mul x (int_pow x xa))"
+  by (import hollight sth)
+
+lemma INT_INTEGRAL: "(ALL x. int_mul (int_of_num 0) x = int_of_num 0) &
+(ALL x y z. (int_add x y = int_add x z) = (y = z)) &
+(ALL w x y z.
+    (int_add (int_mul w y) (int_mul x z) =
+     int_add (int_mul w z) (int_mul x y)) =
+    (w = x | y = z))"
+  by (import hollight INT_INTEGRAL)
+
+lemma INT_DIVMOD_UNIQ: "m = int_add (int_mul q n) r & int_le (int_of_num 0) r & int_lt r (int_abs n)
+==> div m n = q & rem m n = r"
+  by (import hollight INT_DIVMOD_UNIQ)
+
+consts
+  eqeq :: "'A => 'A => ('A => 'A => bool) => bool" 
+
+defs
+  eqeq_def: "hollight.eqeq == %(u::'A) (ua::'A) ub::'A => 'A => bool. ub u ua"
+
+lemma DEF__equal__equal_: "hollight.eqeq = (%(u::'A) (ua::'A) ub::'A => 'A => bool. ub u ua)"
+  by (import hollight DEF__equal__equal_)
+
+definition
+  real_mod :: "hollight.real => hollight.real => hollight.real => bool"  where
+  "real_mod == %u ua ub. EX q. integer q & real_sub ua ub = real_mul q u"
+
+lemma DEF_real_mod: "real_mod = (%u ua ub. EX q. integer q & real_sub ua ub = real_mul q u)"
+  by (import hollight DEF_real_mod)
+
+definition
+  int_divides :: "hollight.int => hollight.int => bool"  where
+  "int_divides == %u ua. EX x. ua = int_mul u x"
+
+lemma DEF_int_divides: "int_divides = (%u ua. EX x. ua = int_mul u x)"
+  by (import hollight DEF_int_divides)
+
+consts
+  int_mod :: "hollight.int => hollight.int => hollight.int => bool" 
+
+defs
+  int_mod_def: "hollight.int_mod == %u ua ub. int_divides u (int_sub ua ub)"
+
+lemma DEF_int_mod: "hollight.int_mod = (%u ua ub. int_divides u (int_sub ua ub))"
+  by (import hollight DEF_int_mod)
+
+lemma int_congruent: "hollight.eqeq x xa (hollight.int_mod xb) =
+(EX d. int_sub x xa = int_mul xb d)"
+  by (import hollight int_congruent)
+
+consts
+  int_coprime :: "hollight.int * hollight.int => bool" 
+
+defs
+  int_coprime_def: "hollight.int_coprime ==
+%u. EX x y. int_add (int_mul (fst u) x) (int_mul (snd u) y) = int_of_num 1"
+
+lemma DEF_int_coprime: "hollight.int_coprime =
+(%u. EX x y. int_add (int_mul (fst u) x) (int_mul (snd u) y) = int_of_num 1)"
+  by (import hollight DEF_int_coprime)
+
+lemma FORALL_UNCURRY: "All (P::('A => 'B => 'C) => bool) =
+(ALL f::'A * 'B => 'C. P (%(a::'A) b::'B. f (a, b)))"
+  by (import hollight FORALL_UNCURRY)
+
+lemma EXISTS_UNCURRY: "Ex (x::('A => 'B => 'C) => bool) =
+(EX f::'A * 'B => 'C. x (%(a::'A) b::'B. f (a, b)))"
+  by (import hollight EXISTS_UNCURRY)
+
+lemma WF_INT_MEASURE: "(ALL x::'A. int_le (int_of_num (0::nat)) ((m::'A => hollight.int) x)) &
+(ALL x::'A. (ALL y::'A. int_lt (m y) (m x) --> (P::'A => bool) y) --> P x)
+==> P (x::'A)"
+  by (import hollight WF_INT_MEASURE)
+
+lemma WF_INT_MEASURE_2: "(ALL (x::'A) y::'B.
+    int_le (int_of_num (0::nat)) ((m::'A => 'B => hollight.int) x y)) &
+(ALL (x::'A) y::'B.
+    (ALL (x'::'A) y'::'B.
+        int_lt (m x' y') (m x y) --> (P::'A => 'B => bool) x' y') -->
+    P x y)
+==> P (x::'A) (xa::'B)"
+  by (import hollight WF_INT_MEASURE_2)
+
+lemma INT_GCD_EXISTS: "EX d. int_divides d a &
+      int_divides d b & (EX x y. d = int_add (int_mul a x) (int_mul b y))"
+  by (import hollight INT_GCD_EXISTS)
+
+lemma INT_GCD_EXISTS_POS: "EX d. int_le (int_of_num 0) d &
+      int_divides d a &
+      int_divides d b & (EX x y. d = int_add (int_mul a x) (int_mul b y))"
+  by (import hollight INT_GCD_EXISTS_POS)
+
+consts
+  int_gcd :: "hollight.int * hollight.int => hollight.int" 
+
+defs
+  int_gcd_def: "hollight.int_gcd ==
+SOME d.
+   ALL a b.
+      int_le (int_of_num 0) (d (a, b)) &
+      int_divides (d (a, b)) a &
+      int_divides (d (a, b)) b &
+      (EX x y. d (a, b) = int_add (int_mul a x) (int_mul b y))"
+
+lemma DEF_int_gcd: "hollight.int_gcd =
+(SOME d.
+    ALL a b.
+       int_le (int_of_num 0) (d (a, b)) &
+       int_divides (d (a, b)) a &
+       int_divides (d (a, b)) b &
+       (EX x y. d (a, b) = int_add (int_mul a x) (int_mul b y)))"
+  by (import hollight DEF_int_gcd)
+
+definition
+  num_of_int :: "hollight.int => nat"  where
+  "num_of_int == %u. SOME n. int_of_num n = u"
+
+lemma DEF_num_of_int: "num_of_int = (%u. SOME n. int_of_num n = u)"
+  by (import hollight DEF_num_of_int)
+
+lemma NUM_OF_INT_OF_NUM: "num_of_int (int_of_num x) = x"
+  by (import hollight NUM_OF_INT_OF_NUM)
+
+lemma INT_OF_NUM_OF_INT: "int_le (int_of_num 0) x ==> int_of_num (num_of_int x) = x"
+  by (import hollight INT_OF_NUM_OF_INT)
+
+lemma NUM_OF_INT: "int_le (int_of_num 0) x = (int_of_num (num_of_int x) = x)"
+  by (import hollight NUM_OF_INT)
+
+definition
+  num_divides :: "nat => nat => bool"  where
+  "num_divides == %u ua. int_divides (int_of_num u) (int_of_num ua)"
+
+lemma DEF_num_divides: "num_divides = (%u ua. int_divides (int_of_num u) (int_of_num ua))"
+  by (import hollight DEF_num_divides)
+
+definition
+  num_mod :: "nat => nat => nat => bool"  where
+  "num_mod ==
+%u ua ub. hollight.int_mod (int_of_num u) (int_of_num ua) (int_of_num ub)"
+
+lemma DEF_num_mod: "num_mod =
+(%u ua ub. hollight.int_mod (int_of_num u) (int_of_num ua) (int_of_num ub))"
+  by (import hollight DEF_num_mod)
+
+lemma num_congruent: "hollight.eqeq x xa (num_mod xb) =
+hollight.eqeq (int_of_num x) (int_of_num xa)
+ (hollight.int_mod (int_of_num xb))"
+  by (import hollight num_congruent)
+
+definition
+  num_coprime :: "nat * nat => bool"  where
+  "num_coprime ==
+%u. hollight.int_coprime (int_of_num (fst u), int_of_num (snd u))"
+
+lemma DEF_num_coprime: "num_coprime =
+(%u. hollight.int_coprime (int_of_num (fst u), int_of_num (snd u)))"
+  by (import hollight DEF_num_coprime)
+
+definition
+  num_gcd :: "nat * nat => nat"  where
+  "num_gcd ==
+%u. num_of_int (hollight.int_gcd (int_of_num (fst u), int_of_num (snd u)))"
+
+lemma DEF_num_gcd: "num_gcd =
+(%u. num_of_int (hollight.int_gcd (int_of_num (fst u), int_of_num (snd u))))"
+  by (import hollight DEF_num_gcd)
+
+lemma NUM_GCD: "int_of_num (num_gcd (x, xa)) =
+hollight.int_gcd (int_of_num x, int_of_num xa)"
+  by (import hollight NUM_GCD)
+
+lemma IN_ELIM_THM: "(ALL (P::(bool => 'q_43295 => bool) => bool) x::'q_43295.
+    (x : {v::'q_43295. P (SETSPEC v)}) =
+    P (%(p::bool) t::'q_43295. p & x = t)) &
+(ALL (p::'q_43326 => bool) x::'q_43326.
+    (x : {v::'q_43326. EX y::'q_43326. p y & v = y}) = p x) &
+(ALL (P::(bool => 'q_43354 => bool) => bool) x::'q_43354.
+    x \<in> {v::'q_43354. P (SETSPEC v)} =
+    P (%(p::bool) t::'q_43354. p & x = t)) &
+(ALL (p::'q_43383 => bool) x::'q_43383.
+    x \<in> {v::'q_43383. EX y::'q_43383. p y & v = y} = p x) &
+(ALL (p::'q_43400 => bool) x::'q_43400. p x \<longleftrightarrow> p x)"
+  by (import hollight IN_ELIM_THM)
+
+lemma INSERT: "insert (x::'A) (s::'A set) = {u::'A. EX y::'A. (y : s | y = x) & u = y}"
+  by (import hollight INSERT)
+
+definition
+  SING :: "('A set) => bool"  where
+  "SING == %u::'A set. EX x::'A. u = {x}"
+
+lemma DEF_SING: "SING = (%u::'A set. EX x::'A. u = {x})"
+  by (import hollight DEF_SING)
+
+definition
+  INJ :: "('A => 'B) => ('A => bool) => ('B => bool) => bool"  where
+  "INJ ==
+%(u::'A => 'B) (ua::'A => bool) ub::'B => bool.
+   (ALL x::'A. x : ua --> u x : ub) &
+   (ALL (x::'A) y::'A. x : ua & y : ua & u x = u y --> x = y)"
+
+lemma DEF_INJ: "INJ =
+(%(u::'A => 'B) (ua::'A => bool) ub::'B => bool.
+    (ALL x::'A. x : ua --> u x : ub) &
+    (ALL (x::'A) y::'A. x : ua & y : ua & u x = u y --> x = y))"
+  by (import hollight DEF_INJ)
+
+definition
+  SURJ :: "('A => 'B) => ('A => bool) => ('B => bool) => bool"  where
+  "SURJ ==
+%(u::'A => 'B) (ua::'A => bool) ub::'B => bool.
+   (ALL x::'A. x : ua --> u x : ub) &
+   (ALL x::'B. x : ub --> (EX y::'A. y : ua & u y = x))"
+
+lemma DEF_SURJ: "SURJ =
+(%(u::'A => 'B) (ua::'A => bool) ub::'B => bool.
+    (ALL x::'A. x : ua --> u x : ub) &
+    (ALL x::'B. x : ub --> (EX y::'A. y : ua & u y = x)))"
+  by (import hollight DEF_SURJ)
+
+definition
+  BIJ :: "('A => 'B) => ('A => bool) => ('B => bool) => bool"  where
+  "BIJ ==
+%(u::'A => 'B) (ua::'A => bool) ub::'B => bool. INJ u ua ub & SURJ u ua ub"
+
+lemma DEF_BIJ: "BIJ =
+(%(u::'A => 'B) (ua::'A => bool) ub::'B => bool. INJ u ua ub & SURJ u ua ub)"
+  by (import hollight DEF_BIJ)
+
+definition
+  REST :: "('A => bool) => 'A => bool"  where
+  "REST == %u::'A => bool. u - {Eps u}"
+
+lemma DEF_REST: "REST = (%u::'A => bool. u - {Eps u})"
+  by (import hollight DEF_REST)
+
+lemma NOT_IN_EMPTY: "(x::'A) ~: {}"
+  by (import hollight NOT_IN_EMPTY)
+
+lemma IN_UNIONS: "((xa::'A) : Union (x::('A => bool) => bool)) =
+(EX t::'A => bool. t : x & xa : t)"
+  by (import hollight IN_UNIONS)
+
+lemma IN_INTERS: "((xa::'A) : Inter (x::('A => bool) => bool)) =
+(ALL t::'A => bool. t : x --> xa : t)"
+  by (import hollight IN_INTERS)
+
+lemma IN_DELETE: "((xa::'A) : (x::'A => bool) - {xb::'A}) = (xa : x & xa ~= xb)"
+  by (import hollight IN_DELETE)
+
+lemma IN_IMAGE: "((x::'B) : (xb::'A => 'B) ` (xa::'A => bool)) =
+(EX xc::'A. x = xb xc & xc : xa)"
+  by (import hollight IN_IMAGE)
+
+lemma IN_REST: "((x::'A) : REST (xa::'A => bool)) = (x : xa & x ~= Eps xa)"
+  by (import hollight IN_REST)
+
+lemma FORALL_IN_INSERT: "(ALL xc::'q_44214.
+    xc : insert (xa::'q_44214) (xb::'q_44214 => bool) -->
+    (x::'q_44214 => bool) xc) =
+(x xa & (ALL xa::'q_44214. xa : xb --> x xa))"
+  by (import hollight FORALL_IN_INSERT)
+
+lemma EXISTS_IN_INSERT: "(EX xc::'q_44255.
+    xc : insert (xa::'q_44255) (xb::'q_44255 => bool) &
+    (x::'q_44255 => bool) xc) =
+(x xa | (EX xa::'q_44255. xa : xb & x xa))"
+  by (import hollight EXISTS_IN_INSERT)
+
+lemma CHOICE_DEF: "(x::'A => bool) ~= {} ==> Eps x : x"
+  by (import hollight CHOICE_DEF)
+
+lemma NOT_EQUAL_SETS: "((x::'A => bool) ~= (xa::'A => bool)) = (EX xb::'A. (xb : xa) = (xb ~: x))"
+  by (import hollight NOT_EQUAL_SETS)
+
+lemma EMPTY_NOT_UNIV: "(op ~=::('A::type => bool) => ('A::type => bool) => bool)
+ ({}::'A::type => bool) (UNIV::'A::type => bool)"
+  by (import hollight EMPTY_NOT_UNIV)
+
+lemma EQ_UNIV: "(ALL x::'A. x : (s::'A => bool)) = (s = UNIV)"
+  by (import hollight EQ_UNIV)
+
+lemma SING_SUBSET: "({xa::'q_44493} <= (x::'q_44493 => bool)) = (xa : x)"
+  by (import hollight SING_SUBSET)
+
+lemma PSUBSET_UNIV: "((x::'A => bool) < UNIV) = (EX xa::'A. xa ~: x)"
+  by (import hollight PSUBSET_UNIV)
+
+lemma PSUBSET_ALT: "((x::'A => bool) < (xa::'A => bool)) =
+(x <= xa & (EX a::'A. a : xa & a ~: x))"
+  by (import hollight PSUBSET_ALT)
+
+lemma SUBSET_UNION: "(ALL (x::'A => bool) xa::'A => bool. x <= x Un xa) &
+(ALL (x::'A => bool) xa::'A => bool. x <= xa Un x)"
+  by (import hollight SUBSET_UNION)
+
+lemma UNION_EMPTY: "(ALL x::'A => bool. {} Un x = x) & (ALL x::'A => bool. x Un {} = x)"
+  by (import hollight UNION_EMPTY)
+
+lemma UNION_UNIV: "(ALL x::'A => bool. UNIV Un x = UNIV) &
+(ALL x::'A => bool. x Un UNIV = UNIV)"
+  by (import hollight UNION_UNIV)
+
+lemma INTER_SUBSET: "(ALL (x::'A => bool) xa::'A => bool. x Int xa <= x) &
+(ALL (x::'A => bool) xa::'A => bool. xa Int x <= x)"
+  by (import hollight INTER_SUBSET)
+
+lemma INTER_EMPTY: "(ALL x::'A => bool. {} Int x = {}) & (ALL x::'A => bool. x Int {} = {})"
+  by (import hollight INTER_EMPTY)
+
+lemma INTER_UNIV: "(ALL x::'A => bool. UNIV Int x = x) & (ALL x::'A => bool. x Int UNIV = x)"
+  by (import hollight INTER_UNIV)
+
+lemma IN_DISJOINT: "((x::'A => bool) Int (xa::'A => bool) = {}) =
+(~ (EX xb::'A. xb : x & xb : xa))"
+  by (import hollight IN_DISJOINT)
+
+lemma DISJOINT_SYM: "((x::'A => bool) Int (xa::'A => bool) = {}) = (xa Int x = {})"
+  by (import hollight DISJOINT_SYM)
+
+lemma DISJOINT_EMPTY: "{} Int (x::'A => bool) = {} & x Int {} = {}"
+  by (import hollight DISJOINT_EMPTY)
+
+lemma DISJOINT_EMPTY_REFL: "((x::'A => bool) = {}) = (x Int x = {})"
+  by (import hollight DISJOINT_EMPTY_REFL)
+
+lemma DISJOINT_UNION: "(((x::'A => bool) Un (xa::'A => bool)) Int (xb::'A => bool) = {}) =
+(x Int xb = {} & xa Int xb = {})"
+  by (import hollight DISJOINT_UNION)
+
+lemma DECOMPOSITION: "((x::'A) : (s::'A => bool)) = (EX t::'A => bool. s = insert x t & x ~: t)"
+  by (import hollight DECOMPOSITION)
+
+lemma SET_CASES: "(s::'A => bool) = {} | (EX (x::'A) t::'A => bool. s = insert x t & x ~: t)"
+  by (import hollight SET_CASES)
+
+lemma ABSORPTION: "((x::'A) : (xa::'A => bool)) = (insert x xa = xa)"
+  by (import hollight ABSORPTION)
+
+lemma INSERT_UNIV: "insert (x::'A) UNIV = UNIV"
+  by (import hollight INSERT_UNIV)
+
+lemma INSERT_UNION: "insert (x::'A) (s::'A => bool) Un (t::'A => bool) =
+(if x : t then s Un t else insert x (s Un t))"
+  by (import hollight INSERT_UNION)
+
+lemma DISJOINT_INSERT: "(insert (x::'A) (xa::'A => bool) Int (xb::'A => bool) = {}) =
+(xa Int xb = {} & x ~: xb)"
+  by (import hollight DISJOINT_INSERT)
+
+lemma INSERT_AC: "insert (x::'q_45764) (insert (y::'q_45764) (s::'q_45764 => bool)) =
+insert y (insert x s) &
+insert x (insert x s) = insert x s"
+  by (import hollight INSERT_AC)
+
+lemma INTER_ACI: "(p::'q_45831 => bool) Int (q::'q_45831 => bool) = q Int p &
+p Int q Int (r::'q_45831 => bool) = p Int (q Int r) &
+p Int (q Int r) = q Int (p Int r) & p Int p = p & p Int (p Int q) = p Int q"
+  by (import hollight INTER_ACI)
+
+lemma UNION_ACI: "(p::'q_45897 => bool) Un (q::'q_45897 => bool) = q Un p &
+p Un q Un (r::'q_45897 => bool) = p Un (q Un r) &
+p Un (q Un r) = q Un (p Un r) & p Un p = p & p Un (p Un q) = p Un q"
+  by (import hollight UNION_ACI)
+
+lemma DELETE_NON_ELEMENT: "((x::'A) ~: (xa::'A => bool)) = (xa - {x} = xa)"
+  by (import hollight DELETE_NON_ELEMENT)
+
+lemma IN_DELETE_EQ: "(((x::'A) : (s::'A => bool)) = ((x'::'A) : s)) =
+((x : s - {x'}) = (x' : s - {x}))"
+  by (import hollight IN_DELETE_EQ)
+
+lemma EMPTY_DELETE: "{} - {x::'A} = {}"
+  by (import hollight EMPTY_DELETE)
+
+lemma DELETE_DELETE: "(xa::'A => bool) - {x::'A} - {x} = xa - {x}"
+  by (import hollight DELETE_DELETE)
+
+lemma DELETE_COMM: "(xb::'A => bool) - {x::'A} - {xa::'A} = xb - {xa} - {x}"
+  by (import hollight DELETE_COMM)
+
+lemma DELETE_SUBSET: "(xa::'A => bool) - {x::'A} <= xa"
+  by (import hollight DELETE_SUBSET)
+
+lemma SUBSET_DELETE: "((xa::'A => bool) <= (xb::'A => bool) - {x::'A}) = (x ~: xa & xa <= xb)"
+  by (import hollight SUBSET_DELETE)
+
+lemma SUBSET_INSERT_DELETE: "((xa::'A => bool) <= insert (x::'A) (xb::'A => bool)) = (xa - {x} <= xb)"
+  by (import hollight SUBSET_INSERT_DELETE)
+
+lemma PSUBSET_INSERT_SUBSET: "((x::'A => bool) < (xa::'A => bool)) =
+(EX xb::'A. xb ~: x & insert xb x <= xa)"
+  by (import hollight PSUBSET_INSERT_SUBSET)
+
+lemma PSUBSET_MEMBER: "((x::'A => bool) < (xa::'A => bool)) =
+(x <= xa & (EX y::'A. y : xa & y ~: x))"
+  by (import hollight PSUBSET_MEMBER)
+
+lemma DELETE_INSERT: "insert (x::'A) (s::'A => bool) - {y::'A} =
+(if x = y then s - {y} else insert x (s - {y}))"
+  by (import hollight DELETE_INSERT)
+
+lemma DELETE_INTER: "((x::'A => bool) - {xb::'A}) Int (xa::'A => bool) = x Int xa - {xb}"
+  by (import hollight DELETE_INTER)
+
+lemma DISJOINT_DELETE_SYM: "(((x::'A => bool) - {xb::'A}) Int (xa::'A => bool) = {}) =
+((xa - {xb}) Int x = {})"
+  by (import hollight DISJOINT_DELETE_SYM)
+
+lemma FORALL_IN_UNIONS: "(ALL x::'q_46386.
+    x : Union (s::('q_46386 => bool) => bool) --> (P::'q_46386 => bool) x) =
+(ALL (t::'q_46386 => bool) x::'q_46386. t : s & x : t --> P x)"
+  by (import hollight FORALL_IN_UNIONS)
+
+lemma EXISTS_IN_UNIONS: "(EX x::'q_46428.
+    x : Union (s::('q_46428 => bool) => bool) & (P::'q_46428 => bool) x) =
+(EX (t::'q_46428 => bool) x::'q_46428. t : s & x : t & P x)"
+  by (import hollight EXISTS_IN_UNIONS)
+
+lemma EMPTY_UNIONS: "(Union (x::('q_46454 => bool) => bool) = {}) =
+(ALL xa::'q_46454 => bool. xa : x --> xa = {})"
+  by (import hollight EMPTY_UNIONS)
+
+lemma INTER_UNIONS: "(ALL (x::('q_46493 => bool) => bool) xa::'q_46493 => bool.
+    Union x Int xa =
+    Union
+     {u::'q_46493 => bool.
+      EX xb::'q_46493 => bool. xb : x & u = xb Int xa}) &
+(ALL (x::('q_46529 => bool) => bool) xa::'q_46529 => bool.
+    xa Int Union x =
+    Union
+     {u::'q_46529 => bool. EX xb::'q_46529 => bool. xb : x & u = xa Int xb})"
+  by (import hollight INTER_UNIONS)
+
+lemma UNIONS_SUBSET: "(Union (x::('q_46545 => bool) => bool) <= (xa::'q_46545 => bool)) =
+(ALL xb::'q_46545 => bool. xb : x --> xb <= xa)"
+  by (import hollight UNIONS_SUBSET)
+
+lemma IMAGE_CLAUSES: "(f::'q_46676 => 'q_46680) ` {} = {} &
+f ` insert (x::'q_46676) (s::'q_46676 => bool) = insert (f x) (f ` s)"
+  by (import hollight IMAGE_CLAUSES)
+
+lemma IMAGE_INTER_INJ: "(!!(xa::'q_46846) y::'q_46846.
+    (x::'q_46846 => 'q_46857) xa = x y ==> xa = y)
+==> x ` ((xa::'q_46846 => bool) Int (xb::'q_46846 => bool)) =
+    x ` xa Int x ` xb"
+  by (import hollight IMAGE_INTER_INJ)
+
+lemma IMAGE_DIFF_INJ: "(!!(xa::'q_46900) y::'q_46900.
+    (x::'q_46900 => 'q_46911) xa = x y ==> xa = y)
+==> x ` ((xa::'q_46900 => bool) - (xb::'q_46900 => bool)) = x ` xa - x ` xb"
+  by (import hollight IMAGE_DIFF_INJ)
+
+lemma IMAGE_DELETE_INJ: "(!!xa::'q_46958.
+    (x::'q_46958 => 'q_46957) xa = x (xb::'q_46958) ==> xa = xb)
+==> x ` ((xa::'q_46958 => bool) - {xb}) = x ` xa - {x xb}"
+  by (import hollight IMAGE_DELETE_INJ)
+
+lemma FORALL_IN_IMAGE: "(ALL xb::'q_47016.
+    xb : (x::'q_47017 => 'q_47016) ` (xa::'q_47017 => bool) -->
+    (P::'q_47016 => bool) xb) =
+(ALL xb::'q_47017. xb : xa --> P (x xb))"
+  by (import hollight FORALL_IN_IMAGE)
+
+lemma EXISTS_IN_IMAGE: "(EX xb::'q_47052.
+    xb : (x::'q_47053 => 'q_47052) ` (xa::'q_47053 => bool) &
+    (P::'q_47052 => bool) xb) =
+(EX xb::'q_47053. xb : xa & P (x xb))"
+  by (import hollight EXISTS_IN_IMAGE)
+
+lemma FORALL_SUBSET_IMAGE: "(ALL xc<=(xa::'q_47140 => 'q_47156) ` (xb::'q_47140 => bool).
+    (x::('q_47156 => bool) => bool) xc) =
+(ALL t<=xb. x (xa ` t))"
+  by (import hollight FORALL_SUBSET_IMAGE)
+
+lemma EXISTS_SUBSET_IMAGE: "(EX xc<=(xa::'q_47183 => 'q_47199) ` (xb::'q_47183 => bool).
+    (x::('q_47199 => bool) => bool) xc) =
+(EX t<=xb. x (xa ` t))"
+  by (import hollight EXISTS_SUBSET_IMAGE)
+
+lemma SIMPLE_IMAGE: "{u::'q_47262.
+ EX xb::'q_47258.
+    xb : (xa::'q_47258 => bool) & u = (x::'q_47258 => 'q_47262) xb} =
+x ` xa"
+  by (import hollight SIMPLE_IMAGE)
+
+lemma SIMPLE_IMAGE_GEN: "{u::'q_47292.
+ EX xa::'q_47305.
+    (P::'q_47305 => bool) xa & u = (x::'q_47305 => 'q_47292) xa} =
+x ` {u::'q_47305. EX x::'q_47305. P x & u = x}"
+  by (import hollight SIMPLE_IMAGE_GEN)
+
+lemma IMAGE_UNIONS: "(x::'q_47323 => 'q_47332) ` Union (xa::('q_47323 => bool) => bool) =
+Union (op ` x ` xa)"
+  by (import hollight IMAGE_UNIONS)
+
+lemma SURJECTIVE_IMAGE_EQ: "(ALL y::'q_47396.
+    y : (xa::'q_47396 => bool) -->
+    (EX x::'q_47400. (f::'q_47400 => 'q_47396) x = y)) &
+(ALL xb::'q_47400. (f xb : xa) = (xb : (x::'q_47400 => bool)))
+==> f ` x = xa"
+  by (import hollight SURJECTIVE_IMAGE_EQ)
+
+lemma EMPTY_GSPEC: "{u::'q_47425. Ex (SETSPEC u False)} = {}"
+  by (import hollight EMPTY_GSPEC)
+
+lemma SING_GSPEC: "(ALL x::'q_47454. {u::'q_47454. EX xa::'q_47454. xa = x & u = xa} = {x}) &
+(ALL x::'q_47480. {u::'q_47480. EX xa::'q_47480. x = xa & u = xa} = {x})"
+  by (import hollight SING_GSPEC)
+
+lemma IN_ELIM_PAIR_THM: "((xa::'q_47526, xb::'q_47525)
+ : {xa::'q_47526 * 'q_47525.
+    EX (xb::'q_47526) y::'q_47525.
+       (x::'q_47526 => 'q_47525 => bool) xb y & xa = (xb, y)}) =
+x xa xb"
+  by (import hollight IN_ELIM_PAIR_THM)
+
+lemma SET_PAIR_THM: "{u::'q_47570 * 'q_47569.
+ EX p::'q_47570 * 'q_47569. (x::'q_47570 * 'q_47569 => bool) p & u = p} =
+{u::'q_47570 * 'q_47569.
+ EX (a::'q_47570) b::'q_47569. x (a, b) & u = (a, b)}"
+  by (import hollight SET_PAIR_THM)
+
+lemma FORALL_IN_GSPEC: "(ALL (P::'q_47618 => bool) f::'q_47618 => 'q_47739.
+    (ALL z::'q_47739.
+        z : {u::'q_47739. EX x::'q_47618. P x & u = f x} -->
+        (Q::'q_47739 => bool) z) =
+    (ALL x::'q_47618. P x --> Q (f x))) &
+(ALL (P::'q_47675 => 'q_47674 => bool) f::'q_47675 => 'q_47674 => 'q_47739.
+    (ALL z::'q_47739.
+        z : {u::'q_47739.
+             EX (x::'q_47675) y::'q_47674. P x y & u = f x y} -->
+        Q z) =
+    (ALL (x::'q_47675) y::'q_47674. P x y --> Q (f x y))) &
+(ALL (P::'q_47742 => 'q_47741 => 'q_47740 => bool)
+    f::'q_47742 => 'q_47741 => 'q_47740 => 'q_47739.
+    (ALL z::'q_47739.
+        z : {u::'q_47739.
+             EX (w::'q_47742) (x::'q_47741) y::'q_47740.
+                P w x y & u = f w x y} -->
+        Q z) =
+    (ALL (w::'q_47742) (x::'q_47741) y::'q_47740. P w x y --> Q (f w x y)))"
+  by (import hollight FORALL_IN_GSPEC)
+
+lemma EXISTS_IN_GSPEC: "(ALL (P::'q_47788 => bool) f::'q_47788 => 'q_47909.
+    (EX z::'q_47909.
+        z : {u::'q_47909. EX x::'q_47788. P x & u = f x} &
+        (Q::'q_47909 => bool) z) =
+    (EX x::'q_47788. P x & Q (f x))) &
+(ALL (P::'q_47845 => 'q_47844 => bool) f::'q_47845 => 'q_47844 => 'q_47909.
+    (EX z::'q_47909.
+        z : {u::'q_47909. EX (x::'q_47845) y::'q_47844. P x y & u = f x y} &
+        Q z) =
+    (EX (x::'q_47845) y::'q_47844. P x y & Q (f x y))) &
+(ALL (P::'q_47912 => 'q_47911 => 'q_47910 => bool)
+    f::'q_47912 => 'q_47911 => 'q_47910 => 'q_47909.
+    (EX z::'q_47909.
+        z : {u::'q_47909.
+             EX (w::'q_47912) (x::'q_47911) y::'q_47910.
+                P w x y & u = f w x y} &
+        Q z) =
+    (EX (w::'q_47912) (x::'q_47911) y::'q_47910. P w x y & Q (f w x y)))"
+  by (import hollight EXISTS_IN_GSPEC)
+
+lemma SET_PROVE_CASES: "(P::('A => bool) => bool) {} &
+(ALL (a::'A) s::'A => bool. a ~: s --> P (insert a s))
+==> P (x::'A => bool)"
+  by (import hollight SET_PROVE_CASES)
+
+lemma UNIONS_IMAGE: "Union ((f::'q_47989 => 'q_47973 => bool) ` (s::'q_47989 => bool)) =
+{u::'q_47973. EX y::'q_47973. (EX x::'q_47989. x : s & y : f x) & u = y}"
+  by (import hollight UNIONS_IMAGE)
+
+lemma INTERS_IMAGE: "Inter ((f::'q_48032 => 'q_48016 => bool) ` (s::'q_48032 => bool)) =
+{u::'q_48016. EX y::'q_48016. (ALL x::'q_48032. x : s --> y : f x) & u = y}"
+  by (import hollight INTERS_IMAGE)
+
+lemma UNIONS_GSPEC: "(ALL (P::'q_48085 => bool) f::'q_48085 => 'q_48071 => bool.
+    Union {u::'q_48071 => bool. EX x::'q_48085. P x & u = f x} =
+    {u::'q_48071.
+     EX a::'q_48071. (EX x::'q_48085. P x & a : f x) & u = a}) &
+(ALL (P::'q_48149 => 'q_48148 => bool)
+    f::'q_48149 => 'q_48148 => 'q_48129 => bool.
+    Union
+     {u::'q_48129 => bool.
+      EX (x::'q_48149) y::'q_48148. P x y & u = f x y} =
+    {u::'q_48129.
+     EX a::'q_48129.
+        (EX (x::'q_48149) y::'q_48148. P x y & a : f x y) & u = a}) &
+(ALL (P::'q_48223 => 'q_48222 => 'q_48221 => bool)
+    f::'q_48223 => 'q_48222 => 'q_48221 => 'q_48197 => bool.
+    Union
+     {u::'q_48197 => bool.
+      EX (x::'q_48223) (y::'q_48222) z::'q_48221. P x y z & u = f x y z} =
+    {u::'q_48197.
+     EX a::'q_48197.
+        (EX (x::'q_48223) (y::'q_48222) z::'q_48221.
+            P x y z & a : f x y z) &
+        u = a})"
+  by (import hollight UNIONS_GSPEC)
+
+lemma INTERS_GSPEC: "(ALL (P::'q_48276 => bool) f::'q_48276 => 'q_48262 => bool.
+    Inter {u::'q_48262 => bool. EX x::'q_48276. P x & u = f x} =
+    {u::'q_48262.
+     EX a::'q_48262. (ALL x::'q_48276. P x --> a : f x) & u = a}) &
+(ALL (P::'q_48340 => 'q_48339 => bool)
+    f::'q_48340 => 'q_48339 => 'q_48320 => bool.
+    Inter
+     {u::'q_48320 => bool.
+      EX (x::'q_48340) y::'q_48339. P x y & u = f x y} =
+    {u::'q_48320.
+     EX a::'q_48320.
+        (ALL (x::'q_48340) y::'q_48339. P x y --> a : f x y) & u = a}) &
+(ALL (P::'q_48414 => 'q_48413 => 'q_48412 => bool)
+    f::'q_48414 => 'q_48413 => 'q_48412 => 'q_48388 => bool.
+    Inter
+     {u::'q_48388 => bool.
+      EX (x::'q_48414) (y::'q_48413) z::'q_48412. P x y z & u = f x y z} =
+    {u::'q_48388.
+     EX a::'q_48388.
+        (ALL (x::'q_48414) (y::'q_48413) z::'q_48412.
+            P x y z --> a : f x y z) &
+        u = a})"
+  by (import hollight INTERS_GSPEC)
+
+lemma DIFF_INTERS: "(x::'q_48451 => bool) - Inter (xa::('q_48451 => bool) => bool) =
+Union {u::'q_48451 => bool. EX xb::'q_48451 => bool. xb : xa & u = x - xb}"
+  by (import hollight DIFF_INTERS)
+
+lemma INTERS_UNIONS: "Inter (x::('q_48486 => bool) => bool) =
+UNIV -
+Union {u::'q_48486 => bool. EX t::'q_48486 => bool. t : x & u = UNIV - t}"
+  by (import hollight INTERS_UNIONS)
+
+lemma UNIONS_INTERS: "Union (s::('q_48521 => bool) => bool) =
+UNIV -
+Inter {u::'q_48521 => bool. EX t::'q_48521 => bool. t : s & u = UNIV - t}"
+  by (import hollight UNIONS_INTERS)
+
+lemma FINITE_SING: "finite {x::'q_48799}"
+  by (import hollight FINITE_SING)
+
+lemma FINITE_DELETE_IMP: "finite (s::'A => bool) ==> finite (s - {x::'A})"
+  by (import hollight FINITE_DELETE_IMP)
+
+lemma FINITE_DELETE: "finite ((s::'A => bool) - {x::'A}) = finite s"
+  by (import hollight FINITE_DELETE)
+
+lemma FINITE_FINITE_UNIONS: "finite (s::('q_48871 => bool) => bool)
+==> finite (Union s) = (ALL t::'q_48871 => bool. t : s --> finite t)"
+  by (import hollight FINITE_FINITE_UNIONS)
+
+lemma FINITE_IMAGE_EXPAND: "finite (s::'A => bool)
+==> finite
+     {u::'B. EX y::'B. (EX x::'A. x : s & y = (f::'A => 'B) x) & u = y}"
+  by (import hollight FINITE_IMAGE_EXPAND)
+
+lemma FINITE_IMAGE_INJ_GENERAL: "(ALL (x::'A) y::'A.
+    x : (s::'A => bool) & y : s & (f::'A => 'B) x = f y --> x = y) &
+finite (x::'B => bool)
+==> finite {u::'A. EX xa::'A. (xa : s & f xa : x) & u = xa}"
+  by (import hollight FINITE_IMAGE_INJ_GENERAL)
+
+lemma FINITE_FINITE_PREIMAGE_GENERAL: "finite (t::'B => bool) &
+(ALL y::'B.
+    y : t -->
+    finite
+     {u::'A. EX x::'A. (x : (s::'A => bool) & (f::'A => 'B) x = y) & u = x})
+==> finite {u::'A. EX x::'A. (x : s & f x : t) & u = x}"
+  by (import hollight FINITE_FINITE_PREIMAGE_GENERAL)
+
+lemma FINITE_FINITE_PREIMAGE: "finite (t::'B => bool) &
+(ALL y::'B. y : t --> finite {u::'A. EX x::'A. (f::'A => 'B) x = y & u = x})
+==> finite {u::'A. EX x::'A. f x : t & u = x}"
+  by (import hollight FINITE_FINITE_PREIMAGE)
+
+lemma FINITE_IMAGE_INJ_EQ: "(!!(x::'A) y::'A.
+    x : (s::'A => bool) & y : s & (f::'A => 'B) x = f y ==> x = y)
+==> finite (f ` s) = finite s"
+  by (import hollight FINITE_IMAGE_INJ_EQ)
+
+lemma FINITE_IMAGE_INJ: "(ALL (x::'A) y::'A. (f::'A => 'B) x = f y --> x = y) &
+finite (A::'B => bool)
+==> finite {u::'A. EX x::'A. f x : A & u = x}"
+  by (import hollight FINITE_IMAGE_INJ)
+
+lemma INFINITE_IMAGE_INJ: "[| !!(x::'A) y::'A. (f::'A => 'B) x = f y ==> x = y;
+   infinite (s::'A => bool) |]
+==> infinite (f ` s)"
+  by (import hollight INFINITE_IMAGE_INJ)
+
+lemma FINITE_SUBSET_IMAGE: "(finite (t::'B => bool) & t <= (f::'A => 'B) ` (s::'A => bool)) =
+(EX x::'A => bool. finite x & x <= s & t = f ` x)"
+  by (import hollight FINITE_SUBSET_IMAGE)
+
+lemma EXISTS_FINITE_SUBSET_IMAGE: "(EX xc::'q_49755 => bool.
+    finite xc &
+    xc <= (xa::'q_49735 => 'q_49755) ` (xb::'q_49735 => bool) &
+    (x::('q_49755 => bool) => bool) xc) =
+(EX xc::'q_49735 => bool. finite xc & xc <= xb & x (xa ` xc))"
+  by (import hollight EXISTS_FINITE_SUBSET_IMAGE)
+
+lemma FINITE_SUBSET_IMAGE_IMP: "finite (t::'B => bool) & t <= (f::'A => 'B) ` (s::'A => bool)
+==> EX s'::'A => bool. finite s' & s' <= s & t <= f ` s'"
+  by (import hollight FINITE_SUBSET_IMAGE_IMP)
+
+definition
+  FINREC :: "('A => 'B => 'B) => 'B => ('A => bool) => 'B => nat => bool"  where
+  "FINREC ==
+SOME FINREC::('A => 'B => 'B) => 'B => ('A => bool) => 'B => nat => bool.
+   (ALL (f::'A => 'B => 'B) (s::'A => bool) (a::'B) b::'B.
+       FINREC f b s a (0::nat) = (s = {} & a = b)) &
+   (ALL (b::'B) (s::'A => bool) (n::nat) (a::'B) f::'A => 'B => 'B.
+       FINREC f b s a (Suc n) =
+       (EX (x::'A) c::'B. x : s & FINREC f b (s - {x}) c n & a = f x c))"
+
+lemma DEF_FINREC: "FINREC =
+(SOME FINREC::('A => 'B => 'B) => 'B => ('A => bool) => 'B => nat => bool.
+    (ALL (f::'A => 'B => 'B) (s::'A => bool) (a::'B) b::'B.
+        FINREC f b s a (0::nat) = (s = {} & a = b)) &
+    (ALL (b::'B) (s::'A => bool) (n::nat) (a::'B) f::'A => 'B => 'B.
+        FINREC f b s a (Suc n) =
+        (EX (x::'A) c::'B. x : s & FINREC f b (s - {x}) c n & a = f x c)))"
+  by (import hollight DEF_FINREC)
+
+lemma FINREC_1_LEMMA: "FINREC (x::'q_49919 => 'q_49918 => 'q_49918) (xa::'q_49918)
+ (xb::'q_49919 => bool) (xc::'q_49918) (Suc (0::nat)) =
+(EX xd::'q_49919. xb = {xd} & xc = x xd xa)"
+  by (import hollight FINREC_1_LEMMA)
+
+lemma FINREC_SUC_LEMMA: "[| !!(x::'A) (y::'A) s::'B.
+      x ~= y ==> (f::'A => 'B => 'B) x (f y s) = f y (f x s);
+   FINREC f (b::'B) (s::'A => bool) (z::'B) (Suc (n::nat)); (x::'A) : s |]
+==> EX w::'B. FINREC f b (s - {x}) w n & z = f x w"
+  by (import hollight FINREC_SUC_LEMMA)
+
+lemma FINREC_UNIQUE_LEMMA: "[| !!(x::'A) (y::'A) s::'B.
+      x ~= y ==> (f::'A => 'B => 'B) x (f y s) = f y (f x s);
+   FINREC f (b::'B) (s::'A => bool) (a1::'B) (n1::nat) &
+   FINREC f b s (a2::'B) (n2::nat) |]
+==> a1 = a2 & n1 = n2"
+  by (import hollight FINREC_UNIQUE_LEMMA)
+
+lemma FINREC_EXISTS_LEMMA: "finite (s::'A => bool)
+==> EX a::'B. Ex (FINREC (f::'A => 'B => 'B) (b::'B) s a)"
+  by (import hollight FINREC_EXISTS_LEMMA)
+
+lemma FINREC_FUN_LEMMA: "(ALL s::'A.
+    (P::'A => bool) s -->
+    (EX a::'B. Ex ((R::'A => 'B => 'C => bool) s a))) &
+(ALL (n1::'C) (n2::'C) (s::'A) (a1::'B) a2::'B.
+    R s a1 n1 & R s a2 n2 --> a1 = a2 & n1 = n2)
+==> EX x::'A => 'B. ALL (s::'A) a::'B. P s --> Ex (R s a) = (x s = a)"
+  by (import hollight FINREC_FUN_LEMMA)
+
+lemma FINREC_FUN: "(!!(x::'A) (y::'A) s::'B.
+    x ~= y ==> (f::'A => 'B => 'B) x (f y s) = f y (f x s))
+==> EX g::('A => bool) => 'B.
+       g {} = (b::'B) &
+       (ALL (s::'A => bool) x::'A.
+           finite s & x : s --> g s = f x (g (s - {x})))"
+  by (import hollight FINREC_FUN)
+
+lemma SET_RECURSION_LEMMA: "(!!(x::'A) (y::'A) s::'B.
+    x ~= y ==> (f::'A => 'B => 'B) x (f y s) = f y (f x s))
+==> EX g::('A => bool) => 'B.
+       g {} = (b::'B) &
+       (ALL (x::'A) s::'A => bool.
+           finite s --> g (insert x s) = (if x : s then g s else f x (g s)))"
+  by (import hollight SET_RECURSION_LEMMA)
+
+definition
+  ITSET :: "('q_50575 => 'q_50574 => 'q_50574)
+=> ('q_50575 => bool) => 'q_50574 => 'q_50574"  where
+  "ITSET ==
+%(u::'q_50575 => 'q_50574 => 'q_50574) (ua::'q_50575 => bool) ub::'q_50574.
+   (SOME g::('q_50575 => bool) => 'q_50574.
+       g {} = ub &
+       (ALL (x::'q_50575) s::'q_50575 => bool.
+           finite s -->
+           g (insert x s) = (if x : s then g s else u x (g s))))
+    ua"
+
+lemma DEF_ITSET: "ITSET =
+(%(u::'q_50575 => 'q_50574 => 'q_50574) (ua::'q_50575 => bool) ub::'q_50574.
+    (SOME g::('q_50575 => bool) => 'q_50574.
+        g {} = ub &
+        (ALL (x::'q_50575) s::'q_50575 => bool.
+            finite s -->
+            g (insert x s) = (if x : s then g s else u x (g s))))
+     ua)"
+  by (import hollight DEF_ITSET)
+
+lemma FINITE_RECURSION: "(!!(x::'A) (y::'A) s::'B.
+    x ~= y ==> (f::'A => 'B => 'B) x (f y s) = f y (f x s))
+==> ITSET f {} (b::'B) = b &
+    (ALL (x::'A) xa::'A => bool.
+        finite xa -->
+        ITSET f (insert x xa) b =
+        (if x : xa then ITSET f xa b else f x (ITSET f xa b)))"
+  by (import hollight FINITE_RECURSION)
+
+lemma FINITE_RECURSION_DELETE: "(!!(x::'A) (y::'A) s::'B.
+    x ~= y ==> (f::'A => 'B => 'B) x (f y s) = f y (f x s))
+==> ITSET f {} (b::'B) = b &
+    (ALL (x::'A) s::'A => bool.
+        finite s -->
+        ITSET f s b =
+        (if x : s then f x (ITSET f (s - {x}) b) else ITSET f (s - {x}) b))"
+  by (import hollight FINITE_RECURSION_DELETE)
+
+lemma ITSET_EQ: "finite (x::'q_50880 => bool) &
+(ALL xc::'q_50880.
+    xc : x -->
+    (xa::'q_50880 => 'q_50881 => 'q_50881) xc =
+    (xb::'q_50880 => 'q_50881 => 'q_50881) xc) &
+(ALL (x::'q_50880) (y::'q_50880) s::'q_50881.
+    x ~= y --> xa x (xa y s) = xa y (xa x s)) &
+(ALL (x::'q_50880) (y::'q_50880) s::'q_50881.
+    x ~= y --> xb x (xb y s) = xb y (xb x s))
+==> ITSET xa x (xc::'q_50881) = ITSET xb x xc"
+  by (import hollight ITSET_EQ)
+
+lemma SUBSET_RESTRICT: "{u::'q_50914.
+ EX xb::'q_50914.
+    (xb : (x::'q_50914 => bool) & (xa::'q_50914 => bool) xb) & u = xb}
+<= x"
+  by (import hollight SUBSET_RESTRICT)
+
+lemma FINITE_RESTRICT: "finite (s::'A => bool)
+==> finite {u::'A. EX x::'A. (x : s & (P::'A => bool) x) & u = x}"
+  by (import hollight FINITE_RESTRICT)
+
+definition
+  CARD :: "('q_50968 => bool) => nat"  where
+  "CARD == %u::'q_50968 => bool. ITSET (%x::'q_50968. Suc) u (0::nat)"
+
+lemma DEF_CARD: "CARD = (%u::'q_50968 => bool. ITSET (%x::'q_50968. Suc) u (0::nat))"
+  by (import hollight DEF_CARD)
+
+lemma CARD_CLAUSES: "CARD {} = (0::nat) &
+(ALL (x::'A::type) s::'A::type => bool.
+    finite s -->
+    CARD (insert x s) = (if x : s then CARD s else Suc (CARD s)))"
+  by (import hollight CARD_CLAUSES)
+
+lemma CARD_UNION: "finite (x::'A => bool) & finite (xa::'A => bool) & x Int xa = {}
+==> CARD (x Un xa) = CARD x + CARD xa"
+  by (import hollight CARD_UNION)
+
+lemma CARD_DELETE: "finite (s::'A => bool)
+==> CARD (s - {x::'A}) = (if x : s then CARD s - (1::nat) else CARD s)"
+  by (import hollight CARD_DELETE)
+
+lemma CARD_UNION_EQ: "finite (u::'q_51213 => bool) &
+(s::'q_51213 => bool) Int (t::'q_51213 => bool) = {} & s Un t = u
+==> CARD s + CARD t = CARD u"
+  by (import hollight CARD_UNION_EQ)
+
+lemma CARD_DIFF: "finite (s::'q_51270 => bool) & (t::'q_51270 => bool) <= s
+==> CARD (s - t) = CARD s - CARD t"
+  by (import hollight CARD_DIFF)
+
+lemma CARD_EQ_0: "finite (s::'q_51308 => bool) ==> (CARD s = (0::nat)) = (s = {})"
+  by (import hollight CARD_EQ_0)
+
+lemma FINITE_INDUCT_DELETE: "[| (P::('A => bool) => bool) {} &
+   (ALL s::'A => bool.
+       finite s & s ~= {} --> (EX x::'A. x : s & (P (s - {x}) --> P s)));
+   finite (s::'A => bool) |]
+==> P s"
+  by (import hollight FINITE_INDUCT_DELETE)
+
+definition
+  HAS_SIZE :: "('q_51427 => bool) => nat => bool"  where
+  "HAS_SIZE == %(u::'q_51427 => bool) ua::nat. finite u & CARD u = ua"
+
+lemma DEF_HAS_SIZE: "HAS_SIZE = (%(u::'q_51427 => bool) ua::nat. finite u & CARD u = ua)"
+  by (import hollight DEF_HAS_SIZE)
+
+lemma HAS_SIZE_CARD: "HAS_SIZE (x::'q_51446 => bool) (xa::nat) ==> CARD x = xa"
+  by (import hollight HAS_SIZE_CARD)
+
+lemma HAS_SIZE_0: "HAS_SIZE (s::'A => bool) (0::nat) = (s = {})"
+  by (import hollight HAS_SIZE_0)
+
+lemma HAS_SIZE_SUC: "HAS_SIZE (s::'A => bool) (Suc (n::nat)) =
+(s ~= {} & (ALL x::'A. x : s --> HAS_SIZE (s - {x}) n))"
+  by (import hollight HAS_SIZE_SUC)
+
+lemma HAS_SIZE_UNION: "HAS_SIZE (x::'q_51584 => bool) (xb::nat) &
+HAS_SIZE (xa::'q_51584 => bool) (xc::nat) & x Int xa = {}
+==> HAS_SIZE (x Un xa) (xb + xc)"
+  by (import hollight HAS_SIZE_UNION)
+
+lemma HAS_SIZE_DIFF: "HAS_SIZE (x::'q_51620 => bool) (xb::nat) &
+HAS_SIZE (xa::'q_51620 => bool) (xc::nat) & xa <= x
+==> HAS_SIZE (x - xa) (xb - xc)"
+  by (import hollight HAS_SIZE_DIFF)
+
+lemma HAS_SIZE_UNIONS: "HAS_SIZE (x::'A => bool) (xb::nat) &
+(ALL xb::'A. xb : x --> HAS_SIZE ((xa::'A => 'B => bool) xb) (xc::nat)) &
+(ALL (xb::'A) y::'A. xb : x & y : x & xb ~= y --> xa xb Int xa y = {})
+==> HAS_SIZE (Union {u::'B => bool. EX xb::'A. xb : x & u = xa xb})
+     (xb * xc)"
+  by (import hollight HAS_SIZE_UNIONS)
+
+lemma FINITE_HAS_SIZE: "finite (x::'q_51824 => bool) = HAS_SIZE x (CARD x)"
+  by (import hollight FINITE_HAS_SIZE)
+
+lemma HAS_SIZE_CLAUSES: "HAS_SIZE (s::'q_51886 => bool) (0::nat) = (s = {}) &
+HAS_SIZE s (Suc (n::nat)) =
+(EX (a::'q_51886) t::'q_51886 => bool.
+    HAS_SIZE t n & a ~: t & s = insert a t)"
+  by (import hollight HAS_SIZE_CLAUSES)
+
+lemma CARD_SUBSET_EQ: "finite (b::'A => bool) & (a::'A => bool) <= b & CARD a = CARD b ==> a = b"
+  by (import hollight CARD_SUBSET_EQ)
+
+lemma CARD_SUBSET: "(a::'A => bool) <= (b::'A => bool) & finite b ==> CARD a <= CARD b"
+  by (import hollight CARD_SUBSET)
+
+lemma CARD_SUBSET_LE: "finite (b::'A => bool) & (a::'A => bool) <= b & CARD b <= CARD a ==> a = b"
+  by (import hollight CARD_SUBSET_LE)
+
+lemma SUBSET_CARD_EQ: "finite (t::'q_52197 => bool) & (s::'q_52197 => bool) <= t
+==> (CARD s = CARD t) = (s = t)"
+  by (import hollight SUBSET_CARD_EQ)
+
+lemma CARD_PSUBSET: "(a::'A => bool) < (b::'A => bool) & finite b ==> CARD a < CARD b"
+  by (import hollight CARD_PSUBSET)
+
+lemma CARD_UNION_LE: "finite (s::'A => bool) & finite (t::'A => bool)
+==> CARD (s Un t) <= CARD s + CARD t"
+  by (import hollight CARD_UNION_LE)
+
+lemma CARD_UNIONS_LE: "HAS_SIZE (x::'A => bool) (xb::nat) &
+(ALL xb::'A.
+    xb : x -->
+    finite ((xa::'A => 'B => bool) xb) & CARD (xa xb) <= (xc::nat))
+==> CARD (Union {u::'B => bool. EX xb::'A. xb : x & u = xa xb}) <= xb * xc"
+  by (import hollight CARD_UNIONS_LE)
+
+lemma CARD_UNION_GEN: "finite (s::'q_52620 => bool) & finite (t::'q_52620 => bool)
+==> CARD (s Un t) = CARD s + CARD t - CARD (s Int t)"
+  by (import hollight CARD_UNION_GEN)
+
+lemma CARD_UNION_OVERLAP_EQ: "finite (s::'q_52701 => bool) & finite (t::'q_52701 => bool)
+==> (CARD (s Un t) = CARD s + CARD t) = (s Int t = {})"
+  by (import hollight CARD_UNION_OVERLAP_EQ)
+
+lemma CARD_UNION_OVERLAP: "finite (x::'q_52743 => bool) &
+finite (xa::'q_52743 => bool) & CARD (x Un xa) < CARD x + CARD xa
+==> x Int xa ~= {}"
+  by (import hollight CARD_UNION_OVERLAP)
+
+lemma CARD_IMAGE_INJ: "(ALL (xa::'A) y::'A.
+    xa : (x::'A => bool) & y : x & (f::'A => 'B) xa = f y --> xa = y) &
+finite x
+==> CARD (f ` x) = CARD x"
+  by (import hollight CARD_IMAGE_INJ)
+
+lemma HAS_SIZE_IMAGE_INJ: "(ALL (xb::'A) y::'A.
+    xb : (xa::'A => bool) & y : xa & (x::'A => 'B) xb = x y --> xb = y) &
+HAS_SIZE xa (xb::nat)
+==> HAS_SIZE (x ` xa) xb"
+  by (import hollight HAS_SIZE_IMAGE_INJ)
+
+lemma CARD_IMAGE_LE: "finite (s::'A => bool) ==> CARD ((f::'A => 'B) ` s) <= CARD s"
+  by (import hollight CARD_IMAGE_LE)
+
+lemma CARD_IMAGE_INJ_EQ: "finite (s::'A => bool) &
+(ALL x::'A. x : s --> (f::'A => 'B) x : (t::'B => bool)) &
+(ALL y::'B. y : t --> (EX! x::'A. x : s & f x = y))
+==> CARD t = CARD s"
+  by (import hollight CARD_IMAGE_INJ_EQ)
+
+lemma CARD_SUBSET_IMAGE: "finite (t::'q_52977 => bool) &
+(s::'q_52984 => bool) <= (f::'q_52977 => 'q_52984) ` t
+==> CARD s <= CARD t"
+  by (import hollight CARD_SUBSET_IMAGE)
+
+lemma HAS_SIZE_IMAGE_INJ_EQ: "(!!(x::'q_53049) y::'q_53049.
+    x : (s::'q_53049 => bool) & y : s & (f::'q_53049 => 'q_53044) x = f y
+    ==> x = y)
+==> HAS_SIZE (f ` s) (n::nat) = HAS_SIZE s n"
+  by (import hollight HAS_SIZE_IMAGE_INJ_EQ)
+
+lemma CHOOSE_SUBSET_STRONG: "(finite (s::'A => bool) ==> (n::nat) <= CARD s) ==> EX t<=s. HAS_SIZE t n"
+  by (import hollight CHOOSE_SUBSET_STRONG)
+
+lemma CHOOSE_SUBSET: "[| finite (s::'A => bool); (n::nat) <= CARD s |] ==> EX t<=s. HAS_SIZE t n"
+  by (import hollight CHOOSE_SUBSET)
+
+lemma HAS_SIZE_PRODUCT_DEPENDENT: "HAS_SIZE (x::'A => bool) (xa::nat) &
+(ALL xa::'A. xa : x --> HAS_SIZE ((xb::'A => 'B => bool) xa) (xc::nat))
+==> HAS_SIZE
+     {u::'A * 'B. EX (xa::'A) y::'B. (xa : x & y : xb xa) & u = (xa, y)}
+     (xa * xc)"
+  by (import hollight HAS_SIZE_PRODUCT_DEPENDENT)
+
+lemma FINITE_PRODUCT_DEPENDENT: "finite (s::'A => bool) &
+(ALL x::'A. x : s --> finite ((t::'A => 'B => bool) x))
+==> finite
+     {u::'C.
+      EX (x::'A) y::'B. (x : s & y : t x) & u = (f::'A => 'B => 'C) x y}"
+  by (import hollight FINITE_PRODUCT_DEPENDENT)
+
+lemma FINITE_PRODUCT: "finite (x::'A => bool) & finite (xa::'B => bool)
+==> finite {u::'A * 'B. EX (xb::'A) y::'B. (xb : x & y : xa) & u = (xb, y)}"
+  by (import hollight FINITE_PRODUCT)
+
+lemma CARD_PRODUCT: "finite (s::'A => bool) & finite (t::'B => bool)
+==> CARD {u::'A * 'B. EX (x::'A) y::'B. (x : s & y : t) & u = (x, y)} =
+    CARD s * CARD t"
+  by (import hollight CARD_PRODUCT)
+
+lemma HAS_SIZE_PRODUCT: "HAS_SIZE (x::'A => bool) (xa::nat) & HAS_SIZE (xb::'B => bool) (xc::nat)
+==> HAS_SIZE
+     {u::'A * 'B. EX (xa::'A) y::'B. (xa : x & y : xb) & u = (xa, y)}
+     (xa * xc)"
+  by (import hollight HAS_SIZE_PRODUCT)
+
+definition
+  CROSS :: "('q_53759 => bool) => ('q_53758 => bool) => 'q_53759 * 'q_53758 => bool"  where
+  "CROSS ==
+%(u::'q_53759 => bool) ua::'q_53758 => bool.
+   {ub::'q_53759 * 'q_53758.
+    EX (x::'q_53759) y::'q_53758. (x : u & y : ua) & ub = (x, y)}"
+
+lemma DEF_CROSS: "CROSS =
+(%(u::'q_53759 => bool) ua::'q_53758 => bool.
+    {ub::'q_53759 * 'q_53758.
+     EX (x::'q_53759) y::'q_53758. (x : u & y : ua) & ub = (x, y)})"
+  by (import hollight DEF_CROSS)
+
+lemma IN_CROSS: "((x::'q_53795, xa::'q_53798)
+ : CROSS (xb::'q_53795 => bool) (xc::'q_53798 => bool)) =
+(x : xb & xa : xc)"
+  by (import hollight IN_CROSS)
+
+lemma HAS_SIZE_CROSS: "HAS_SIZE (x::'q_53823 => bool) (xb::nat) &
+HAS_SIZE (xa::'q_53826 => bool) (xc::nat)
+==> HAS_SIZE (CROSS x xa) (xb * xc)"
+  by (import hollight HAS_SIZE_CROSS)
+
+lemma FINITE_CROSS: "finite (x::'q_53851 => bool) & finite (xa::'q_53853 => bool)
+==> finite (CROSS x xa)"
+  by (import hollight FINITE_CROSS)
+
+lemma CARD_CROSS: "finite (x::'q_53874 => bool) & finite (xa::'q_53876 => bool)
+==> CARD (CROSS x xa) = CARD x * CARD xa"
+  by (import hollight CARD_CROSS)
+
+lemma CROSS_EQ_EMPTY: "(CROSS (x::'q_53917 => bool) (xa::'q_53921 => bool) = {}) =
+(x = {} | xa = {})"
+  by (import hollight CROSS_EQ_EMPTY)
+
+lemma HAS_SIZE_FUNSPACE: "HAS_SIZE (s::'A => bool) (m::nat) & HAS_SIZE (t::'B => bool) (n::nat)
+==> HAS_SIZE
+     {u::'A => 'B.
+      EX f::'A => 'B.
+         ((ALL x::'A. x : s --> f x : t) &
+          (ALL x::'A. x ~: s --> f x = (d::'B))) &
+         u = f}
+     (n ^ m)"
+  by (import hollight HAS_SIZE_FUNSPACE)
+
+lemma CARD_FUNSPACE: "finite (s::'q_54227 => bool) & finite (t::'q_54224 => bool)
+==> CARD
+     {u::'q_54227 => 'q_54224.
+      EX f::'q_54227 => 'q_54224.
+         ((ALL x::'q_54227. x : s --> f x : t) &
+          (ALL x::'q_54227. x ~: s --> f x = (d::'q_54224))) &
+         u = f} =
+    CARD t ^ CARD s"
+  by (import hollight CARD_FUNSPACE)
+
+lemma FINITE_FUNSPACE: "finite (s::'q_54293 => bool) & finite (t::'q_54290 => bool)
+==> finite
+     {u::'q_54293 => 'q_54290.
+      EX f::'q_54293 => 'q_54290.
+         ((ALL x::'q_54293. x : s --> f x : t) &
+          (ALL x::'q_54293. x ~: s --> f x = (d::'q_54290))) &
+         u = f}"
+  by (import hollight FINITE_FUNSPACE)
+
+lemma HAS_SIZE_POWERSET: "HAS_SIZE (s::'A => bool) (n::nat)
+==> HAS_SIZE {u::'A => bool. EX t<=s. u = t} ((2::nat) ^ n)"
+  by (import hollight HAS_SIZE_POWERSET)
+
+lemma CARD_POWERSET: "finite (s::'A => bool)
+==> CARD {u::'A => bool. EX t<=s. u = t} = (2::nat) ^ CARD s"
+  by (import hollight CARD_POWERSET)
+
+lemma FINITE_POWERSET: "finite (s::'A => bool) ==> finite {u::'A => bool. EX t<=s. u = t}"
+  by (import hollight FINITE_POWERSET)
+
+lemma FINITE_UNIONS: "finite (Union (s::('A => bool) => bool)) =
+(finite s & (ALL t::'A => bool. t : s --> finite t))"
+  by (import hollight FINITE_UNIONS)
+
+lemma POWERSET_CLAUSES: "{x::'q_54515 => bool. EX xa<={}. x = xa} = {{}} &
+(ALL (x::'A) xa::'A => bool.
+    {xb::'A => bool. EX xc<=insert x xa. xb = xc} =
+    {u::'A => bool. EX s<=xa. u = s} Un
+    insert x ` {u::'A => bool. EX s<=xa. u = s})"
+  by (import hollight POWERSET_CLAUSES)
+
+lemma HAS_SIZE_NUMSEG_LT: "HAS_SIZE {u. EX m<n. u = m} n"
+  by (import hollight HAS_SIZE_NUMSEG_LT)
+
+lemma CARD_NUMSEG_LT: "CARD {u. EX m<x. u = m} = x"
+  by (import hollight CARD_NUMSEG_LT)
+
+lemma FINITE_NUMSEG_LT: "finite {u::nat. EX m<x::nat. u = m}"
+  by (import hollight FINITE_NUMSEG_LT)
+
+lemma HAS_SIZE_NUMSEG_LE: "HAS_SIZE {xa. EX xb<=x. xa = xb} (x + 1)"
+  by (import hollight HAS_SIZE_NUMSEG_LE)
+
+lemma FINITE_NUMSEG_LE: "finite {u::nat. EX m<=x::nat. u = m}"
+  by (import hollight FINITE_NUMSEG_LE)
+
+lemma CARD_NUMSEG_LE: "CARD {u. EX m<=x. u = m} = x + 1"
+  by (import hollight CARD_NUMSEG_LE)
+
+lemma num_FINITE: "finite (s::nat => bool) = (EX a::nat. ALL x::nat. x : s --> x <= a)"
+  by (import hollight num_FINITE)
+
+lemma num_FINITE_AVOID: "finite (s::nat => bool) ==> EX a::nat. a ~: s"
+  by (import hollight num_FINITE_AVOID)
+
+lemma FINITE_REAL_INTERVAL: "(ALL a. infinite {u. EX x. real_lt a x & u = x}) &
+(ALL a. infinite {u. EX x. real_le a x & u = x}) &
+(ALL b. infinite {u. EX x. real_lt x b & u = x}) &
+(ALL b. infinite {u. EX x. real_le x b & u = x}) &
+(ALL x xa.
+    finite {u. EX xb. (real_lt x xb & real_lt xb xa) & u = xb} =
+    real_le xa x) &
+(ALL a b.
+    finite {u. EX x. (real_le a x & real_lt x b) & u = x} = real_le b a) &
+(ALL a b.
+    finite {u. EX x. (real_lt a x & real_le x b) & u = x} = real_le b a) &
+(ALL a b.
+    finite {u. EX x. (real_le a x & real_le x b) & u = x} = real_le b a)"
+  by (import hollight FINITE_REAL_INTERVAL)
+
+lemma real_INFINITE: "(infinite::(hollight.real => bool) => bool) (UNIV::hollight.real => bool)"
+  by (import hollight real_INFINITE)
+
+lemma HAS_SIZE_INDEX: "HAS_SIZE (x::'A => bool) (n::nat)
+==> EX f::nat => 'A.
+       (ALL m<n. f m : x) &
+       (ALL xa::'A. xa : x --> (EX! m::nat. m < n & f m = xa))"
+  by (import hollight HAS_SIZE_INDEX)
+
+definition
+  pairwise :: "('q_55938 => 'q_55938 => bool) => ('q_55938 => bool) => bool"  where
+  "pairwise ==
+%(u::'q_55938 => 'q_55938 => bool) ua::'q_55938 => bool.
+   ALL (x::'q_55938) y::'q_55938. x : ua & y : ua & x ~= y --> u x y"
+
+lemma DEF_pairwise: "pairwise =
+(%(u::'q_55938 => 'q_55938 => bool) ua::'q_55938 => bool.
+    ALL (x::'q_55938) y::'q_55938. x : ua & y : ua & x ~= y --> u x y)"
+  by (import hollight DEF_pairwise)
+
+definition
+  PAIRWISE :: "('A => 'A => bool) => 'A list => bool"  where
+  "PAIRWISE ==
+SOME PAIRWISE::('A => 'A => bool) => 'A list => bool.
+   (ALL r::'A => 'A => bool. PAIRWISE r [] = True) &
+   (ALL (h::'A) (r::'A => 'A => bool) t::'A list.
+       PAIRWISE r (h # t) = (list_all (r h) t & PAIRWISE r t))"
+
+lemma DEF_PAIRWISE: "PAIRWISE =
+(SOME PAIRWISE::('A => 'A => bool) => 'A list => bool.
+    (ALL r::'A => 'A => bool. PAIRWISE r [] = True) &
+    (ALL (h::'A) (r::'A => 'A => bool) t::'A list.
+        PAIRWISE r (h # t) = (list_all (r h) t & PAIRWISE r t)))"
+  by (import hollight DEF_PAIRWISE)
+
+lemma PAIRWISE_EMPTY: "pairwise (x::'q_55973 => 'q_55973 => bool) {} = True"
+  by (import hollight PAIRWISE_EMPTY)
+
+lemma PAIRWISE_SING: "pairwise (x::'q_55991 => 'q_55991 => bool) {xa::'q_55991} = True"
+  by (import hollight PAIRWISE_SING)
+
+lemma PAIRWISE_MONO: "pairwise (x::'q_56011 => 'q_56011 => bool) (xa::'q_56011 => bool) &
+(xb::'q_56011 => bool) <= xa
+==> pairwise x xb"
+  by (import hollight PAIRWISE_MONO)
+
+lemma SURJECTIVE_IFF_INJECTIVE_GEN: "finite (s::'A => bool) &
+finite (t::'B => bool) & CARD s = CARD t & (f::'A => 'B) ` s <= t
+==> (ALL y::'B. y : t --> (EX x::'A. x : s & f x = y)) =
+    (ALL (x::'A) y::'A. x : s & y : s & f x = f y --> x = y)"
+  by (import hollight SURJECTIVE_IFF_INJECTIVE_GEN)
+
+lemma SURJECTIVE_IFF_INJECTIVE: "finite (x::'A => bool) & (xa::'A => 'A) ` x <= x
+==> (ALL y::'A. y : x --> (EX xb::'A. xb : x & xa xb = y)) =
+    (ALL (xb::'A) y::'A. xb : x & y : x & xa xb = xa y --> xb = y)"
+  by (import hollight SURJECTIVE_IFF_INJECTIVE)
+
+lemma IMAGE_IMP_INJECTIVE_GEN: "[| finite (s::'A => bool) &
+   CARD s = CARD (t::'B => bool) & (f::'A => 'B) ` s = t;
+   (x::'A) : s & (y::'A) : s & f x = f y |]
+==> x = y"
+  by (import hollight IMAGE_IMP_INJECTIVE_GEN)
+
+lemma IMAGE_IMP_INJECTIVE: "[| finite (s::'q_56387 => bool) & (f::'q_56387 => 'q_56387) ` s = s;
+   (x::'q_56387) : s & (y::'q_56387) : s & f x = f y |]
+==> x = y"
+  by (import hollight IMAGE_IMP_INJECTIVE)
+
+lemma CARD_LE_INJ: "finite (x::'A => bool) & finite (xa::'B => bool) & CARD x <= CARD xa
+==> EX f::'A => 'B.
+       f ` x <= xa &
+       (ALL (xa::'A) y::'A. xa : x & y : x & f xa = f y --> xa = y)"
+  by (import hollight CARD_LE_INJ)
+
+lemma FORALL_IN_CLAUSES: "(ALL x::'q_56493 => bool. (ALL xa::'q_56493. xa : {} --> x xa) = True) &
+(ALL (x::'q_56533 => bool) (xa::'q_56533) xb::'q_56533 => bool.
+    (ALL xc::'q_56533. xc : insert xa xb --> x xc) =
+    (x xa & (ALL xa::'q_56533. xa : xb --> x xa)))"
+  by (import hollight FORALL_IN_CLAUSES)
+
+lemma EXISTS_IN_CLAUSES: "(ALL x::'q_56553 => bool. (EX xa::'q_56553. xa : {} & x xa) = False) &
+(ALL (x::'q_56593 => bool) (xa::'q_56593) xb::'q_56593 => bool.
+    (EX xc::'q_56593. xc : insert xa xb & x xc) =
+    (x xa | (EX xa::'q_56593. xa : xb & x xa)))"
+  by (import hollight EXISTS_IN_CLAUSES)
+
+lemma SURJECTIVE_ON_RIGHT_INVERSE: "(ALL xb::'q_56650.
+    xb : (xa::'q_56650 => bool) -->
+    (EX xa::'q_56649.
+        xa : (s::'q_56649 => bool) & (x::'q_56649 => 'q_56650) xa = xb)) =
+(EX g::'q_56650 => 'q_56649.
+    ALL y::'q_56650. y : xa --> g y : s & x (g y) = y)"
+  by (import hollight SURJECTIVE_ON_RIGHT_INVERSE)
+
+lemma INJECTIVE_ON_LEFT_INVERSE: "(ALL (xb::'q_56743) y::'q_56743.
+    xb : (xa::'q_56743 => bool) &
+    y : xa & (x::'q_56743 => 'q_56746) xb = x y -->
+    xb = y) =
+(EX xb::'q_56746 => 'q_56743. ALL xc::'q_56743. xc : xa --> xb (x xc) = xc)"
+  by (import hollight INJECTIVE_ON_LEFT_INVERSE)
+
+lemma BIJECTIVE_ON_LEFT_RIGHT_INVERSE: "(!!x::'q_56878.
+    x : (s::'q_56878 => bool)
+    ==> (f::'q_56878 => 'q_56877) x : (t::'q_56877 => bool))
+==> ((ALL (x::'q_56878) y::'q_56878. x : s & y : s & f x = f y --> x = y) &
+     (ALL x::'q_56877. x : t --> (EX xa::'q_56878. xa : s & f xa = x))) =
+    (EX g::'q_56877 => 'q_56878.
+        (ALL y::'q_56877. y : t --> g y : s) &
+        (ALL y::'q_56877. y : t --> f (g y) = y) &
+        (ALL x::'q_56878. x : s --> g (f x) = x))"
+  by (import hollight BIJECTIVE_ON_LEFT_RIGHT_INVERSE)
+
+lemma SURJECTIVE_RIGHT_INVERSE: "(ALL y::'q_56902. EX x::'q_56905. (f::'q_56905 => 'q_56902) x = y) =
+(EX g::'q_56902 => 'q_56905. ALL y::'q_56902. f (g y) = y)"
+  by (import hollight SURJECTIVE_RIGHT_INVERSE)
+
+lemma INJECTIVE_LEFT_INVERSE: "(ALL (x::'q_56939) xa::'q_56939.
+    (f::'q_56939 => 'q_56942) x = f xa --> x = xa) =
+(EX g::'q_56942 => 'q_56939. ALL x::'q_56939. g (f x) = x)"
+  by (import hollight INJECTIVE_LEFT_INVERSE)
+
+lemma BIJECTIVE_LEFT_RIGHT_INVERSE: "((ALL (x::'A) y::'A. (f::'A => 'B) x = f y --> x = y) &
+ (ALL y::'B. EX x::'A. f x = y)) =
+(EX g::'B => 'A. (ALL y::'B. f (g y) = y) & (ALL x::'A. g (f x) = x))"
+  by (import hollight BIJECTIVE_LEFT_RIGHT_INVERSE)
+
+lemma FUNCTION_FACTORS_RIGHT: "(ALL xb::'q_57046.
+    EX y::'q_57034.
+       (xa::'q_57034 => 'q_57047) y = (x::'q_57046 => 'q_57047) xb) =
+(EX xb::'q_57046 => 'q_57034. x = xa o xb)"
+  by (import hollight FUNCTION_FACTORS_RIGHT)
+
+lemma FUNCTION_FACTORS_LEFT: "(ALL (xb::'q_57119) y::'q_57119.
+    (xa::'q_57119 => 'q_57099) xb = xa y -->
+    (x::'q_57119 => 'q_57120) xb = x y) =
+(EX xb::'q_57099 => 'q_57120. x = xb o xa)"
+  by (import hollight FUNCTION_FACTORS_LEFT)
+
+lemma SURJECTIVE_FORALL_THM: "(ALL y::'B. EX x::'A. (f::'A => 'B) x = y) =
+(ALL P::'B => bool. (ALL x::'A. P (f x)) = All P)"
+  by (import hollight SURJECTIVE_FORALL_THM)
+
+lemma SURJECTIVE_EXISTS_THM: "(ALL y::'B. EX x::'A. (f::'A => 'B) x = y) =
+(ALL P::'B => bool. (EX x::'A. P (f x)) = Ex P)"
+  by (import hollight SURJECTIVE_EXISTS_THM)
+
+lemma SURJECTIVE_IMAGE_THM: "(ALL y::'B. EX x::'A. (f::'A => 'B) x = y) =
+(ALL x::'B => bool.
+    f ` {u::'A. EX xa::'A. x (f xa) & u = xa} =
+    {u::'B. EX xa::'B. x xa & u = xa})"
+  by (import hollight SURJECTIVE_IMAGE_THM)
+
+lemma IMAGE_INJECTIVE_IMAGE_OF_SUBSET: "EX x<=s::'A => bool.
+   (f::'A => 'B) ` s = f ` x &
+   (ALL (xa::'A) y::'A. xa : x & y : x & f xa = f y --> xa = y)"
+  by (import hollight IMAGE_INJECTIVE_IMAGE_OF_SUBSET)
+
+lemma INJECTIVE_ON_IMAGE: "(ALL (s::'A => bool) t::'A => bool.
+    s <= (u::'A => bool) & t <= u & (f::'A => 'B) ` s = f ` t --> s = t) =
+(ALL (x::'A) y::'A. x : u & y : u & f x = f y --> x = y)"
+  by (import hollight INJECTIVE_ON_IMAGE)
+
+lemma INJECTIVE_IMAGE: "(ALL (s::'A => bool) t::'A => bool. (f::'A => 'B) ` s = f ` t --> s = t) =
+(ALL (x::'A) y::'A. f x = f y --> x = y)"
+  by (import hollight INJECTIVE_IMAGE)
+
+lemma SURJECTIVE_ON_IMAGE: "(ALL t<=v::'B => bool. EX s<=u::'A => bool. (f::'A => 'B) ` s = t) =
+(ALL y::'B. y : v --> (EX x::'A. x : u & f x = y))"
+  by (import hollight SURJECTIVE_ON_IMAGE)
+
+lemma SURJECTIVE_IMAGE: "(ALL t::'B => bool. EX s::'A => bool. (f::'A => 'B) ` s = t) =
+(ALL y::'B. EX x::'A. f x = y)"
+  by (import hollight SURJECTIVE_IMAGE)
+
+lemma CARD_EQ_BIJECTION: "finite (s::'A => bool) & finite (t::'B => bool) & CARD s = CARD t
+==> EX f::'A => 'B.
+       (ALL x::'A. x : s --> f x : t) &
+       (ALL y::'B. y : t --> (EX x::'A. x : s & f x = y)) &
+       (ALL (x::'A) y::'A. x : s & y : s & f x = f y --> x = y)"
+  by (import hollight CARD_EQ_BIJECTION)
+
+lemma CARD_EQ_BIJECTIONS: "finite (s::'A => bool) & finite (t::'B => bool) & CARD s = CARD t
+==> EX (f::'A => 'B) g::'B => 'A.
+       (ALL x::'A. x : s --> f x : t & g (f x) = x) &
+       (ALL y::'B. y : t --> g y : s & f (g y) = y)"
+  by (import hollight CARD_EQ_BIJECTIONS)
+
+lemma BIJECTIONS_HAS_SIZE: "(ALL x::'A.
+    x : (s::'A => bool) -->
+    (f::'A => 'B) x : (t::'B => bool) & (g::'B => 'A) (f x) = x) &
+(ALL y::'B. y : t --> g y : s & f (g y) = y) & HAS_SIZE s (n::nat)
+==> HAS_SIZE t n"
+  by (import hollight BIJECTIONS_HAS_SIZE)
+
+lemma BIJECTIONS_HAS_SIZE_EQ: "(ALL x::'A.
+    x : (s::'A => bool) -->
+    (f::'A => 'B) x : (t::'B => bool) & (g::'B => 'A) (f x) = x) &
+(ALL y::'B. y : t --> g y : s & f (g y) = y)
+==> HAS_SIZE s (n::nat) = HAS_SIZE t n"
+  by (import hollight BIJECTIONS_HAS_SIZE_EQ)
+
+lemma BIJECTIONS_CARD_EQ: "(finite (s::'A => bool) | finite (t::'B => bool)) &
+(ALL x::'A. x : s --> (f::'A => 'B) x : t & (g::'B => 'A) (f x) = x) &
+(ALL y::'B. y : t --> g y : s & f (g y) = y)
+==> CARD s = CARD t"
+  by (import hollight BIJECTIONS_CARD_EQ)
+
+lemma WF_FINITE: "(ALL x::'A. ~ (u_556::'A => 'A => bool) x x) &
+(ALL (x::'A) (y::'A) z::'A. u_556 x y & u_556 y z --> u_556 x z) &
+(ALL x::'A. finite {u::'A. EX y::'A. u_556 y x & u = y})
+==> wfP u_556"
+  by (import hollight WF_FINITE)
+
+consts
+  "<=_c" :: "('q_58200 => bool) => ('q_58195 => bool) => bool" ("<='_c")
+
+defs
+  "<=_c_def": "<=_c ==
+%(u::'q_58200 => bool) ua::'q_58195 => bool.
+   EX f::'q_58200 => 'q_58195.
+      (ALL x::'q_58200. x : u --> f x : ua) &
+      (ALL (x::'q_58200) y::'q_58200. x : u & y : u & f x = f y --> x = y)"
+
+lemma DEF__lessthan__equal__c: "<=_c =
+(%(u::'q_58200 => bool) ua::'q_58195 => bool.
+    EX f::'q_58200 => 'q_58195.
+       (ALL x::'q_58200. x : u --> f x : ua) &
+       (ALL (x::'q_58200) y::'q_58200. x : u & y : u & f x = f y --> x = y))"
+  by (import hollight DEF__lessthan__equal__c)
+
+consts
+  "<_c" :: "('q_58212 => bool) => ('q_58213 => bool) => bool" ("<'_c")
+
+defs
+  "<_c_def": "<_c == %(u::'q_58212 => bool) ua::'q_58213 => bool. <=_c u ua & ~ <=_c ua u"
+
+lemma DEF__lessthan__c: "<_c = (%(u::'q_58212 => bool) ua::'q_58213 => bool. <=_c u ua & ~ <=_c ua u)"
+  by (import hollight DEF__lessthan__c)
+
+consts
+  "=_c" :: "('q_58264 => bool) => ('q_58261 => bool) => bool" ("='_c")
+
+defs
+  "=_c_def": "=_c ==
+%(u::'q_58264 => bool) ua::'q_58261 => bool.
+   EX f::'q_58264 => 'q_58261.
+      (ALL x::'q_58264. x : u --> f x : ua) &
+      (ALL y::'q_58261. y : ua --> (EX! x::'q_58264. x : u & f x = y))"
+
+lemma DEF__equal__c: "=_c =
+(%(u::'q_58264 => bool) ua::'q_58261 => bool.
+    EX f::'q_58264 => 'q_58261.
+       (ALL x::'q_58264. x : u --> f x : ua) &
+       (ALL y::'q_58261. y : ua --> (EX! x::'q_58264. x : u & f x = y)))"
+  by (import hollight DEF__equal__c)
+
+consts
+  ">=_c" :: "('q_58273 => bool) => ('q_58272 => bool) => bool" (">='_c")
+
+defs
+  ">=_c_def": ">=_c == %(u::'q_58273 => bool) ua::'q_58272 => bool. <=_c ua u"
+
+lemma DEF__greaterthan__equal__c: ">=_c = (%(u::'q_58273 => bool) ua::'q_58272 => bool. <=_c ua u)"
+  by (import hollight DEF__greaterthan__equal__c)
+
+consts
+  ">_c" :: "('q_58282 => bool) => ('q_58281 => bool) => bool" (">'_c")
+
+defs
+  ">_c_def": ">_c == %(u::'q_58282 => bool) ua::'q_58281 => bool. <_c ua u"
+
+lemma DEF__greaterthan__c: ">_c = (%(u::'q_58282 => bool) ua::'q_58281 => bool. <_c ua u)"
+  by (import hollight DEF__greaterthan__c)
+
+lemma LE_C: "<=_c (x::'q_58320 => bool) (xa::'q_58323 => bool) =
+(EX xb::'q_58323 => 'q_58320.
+    ALL xc::'q_58320. xc : x --> (EX x::'q_58323. x : xa & xb x = xc))"
+  by (import hollight LE_C)
+
+lemma GE_C: ">=_c (x::'q_58364 => bool) (xa::'q_58361 => bool) =
+(EX f::'q_58364 => 'q_58361.
+    ALL y::'q_58361. y : xa --> (EX xa::'q_58364. xa : x & y = f xa))"
+  by (import hollight GE_C)
+
+definition
+  COUNTABLE :: "('q_58372 => bool) => bool"  where
+  "(op ==::(('q_58372::type => bool) => bool)
+        => (('q_58372::type => bool) => bool) => prop)
+ (COUNTABLE::('q_58372::type => bool) => bool)
+ ((>=_c::(nat => bool) => ('q_58372::type => bool) => bool)
+   (UNIV::nat => bool))"
+
+lemma DEF_COUNTABLE: "(op =::(('q_58372::type => bool) => bool)
+       => (('q_58372::type => bool) => bool) => bool)
+ (COUNTABLE::('q_58372::type => bool) => bool)
+ ((>=_c::(nat => bool) => ('q_58372::type => bool) => bool)
+   (UNIV::nat => bool))"
+  by (import hollight DEF_COUNTABLE)
+
+lemma NUMSEG_COMBINE_R: "(x::nat) <= (xa::nat) + (1::nat) & xa <= (xb::nat)
+==> {x..xa} Un {xa + (1::nat)..xb} = {x..xb}"
+  by (import hollight NUMSEG_COMBINE_R)
+
+lemma NUMSEG_COMBINE_L: "(x::nat) <= (xa::nat) & xa <= (xb::nat) + (1::nat)
+==> {x..xa - (1::nat)} Un {xa..xb} = {x..xb}"
+  by (import hollight NUMSEG_COMBINE_L)
+
+lemma NUMSEG_LREC: "(x::nat) <= (xa::nat) ==> insert x {x + (1::nat)..xa} = {x..xa}"
+  by (import hollight NUMSEG_LREC)
+
+lemma NUMSEG_RREC: "(x::nat) <= (xa::nat) ==> insert xa {x..xa - (1::nat)} = {x..xa}"
+  by (import hollight NUMSEG_RREC)
+
+lemma IN_NUMSEG_0: "((x::nat) : {0::nat..xa::nat}) = (x <= xa)"
+  by (import hollight IN_NUMSEG_0)
+
+lemma NUMSEG_EMPTY: "({x::nat..xa::nat} = {}) = (xa < x)"
+  by (import hollight NUMSEG_EMPTY)
+
+lemma CARD_NUMSEG_LEMMA: "CARD {m..m + d} = d + 1"
+  by (import hollight CARD_NUMSEG_LEMMA)
+
+lemma CARD_NUMSEG: "CARD {m..n} = n + 1 - m"
+  by (import hollight CARD_NUMSEG)
+
+lemma HAS_SIZE_NUMSEG: "HAS_SIZE {x..xa} (xa + 1 - x)"
+  by (import hollight HAS_SIZE_NUMSEG)
+
+lemma CARD_NUMSEG_1: "CARD {1..x} = x"
+  by (import hollight CARD_NUMSEG_1)
+
+lemma HAS_SIZE_NUMSEG_1: "HAS_SIZE {1..x} x"
+  by (import hollight HAS_SIZE_NUMSEG_1)
+
+lemma NUMSEG_CLAUSES: "(ALL m::nat. {m..0::nat} = (if m = (0::nat) then {0::nat} else {})) &
+(ALL (m::nat) n::nat.
+    {m..Suc n} = (if m <= Suc n then insert (Suc n) {m..n} else {m..n}))"
+  by (import hollight NUMSEG_CLAUSES)
+
+lemma FINITE_INDEX_NUMSEG: "finite (s::'A => bool) =
+(EX f::nat => 'A.
+    (ALL (i::nat) j::nat.
+        i : {1::nat..CARD s} & j : {1::nat..CARD s} & f i = f j --> i = j) &
+    s = f ` {1::nat..CARD s})"
+  by (import hollight FINITE_INDEX_NUMSEG)
+
+lemma FINITE_INDEX_NUMBERS: "finite (s::'A => bool) =
+(EX (k::nat => bool) f::nat => 'A.
+    (ALL (i::nat) j::nat. i : k & j : k & f i = f j --> i = j) &
+    finite k & s = f ` k)"
+  by (import hollight FINITE_INDEX_NUMBERS)
+
+lemma DISJOINT_NUMSEG: "({x::nat..xa::nat} Int {xb::nat..xc::nat} = {}) =
+(xa < xb | xc < x | xa < x | xc < xb)"
+  by (import hollight DISJOINT_NUMSEG)
+
+lemma NUMSEG_ADD_SPLIT: "(x::nat) <= (xa::nat) + (1::nat)
+==> {x..xa + (xb::nat)} = {x..xa} Un {xa + (1::nat)..xa + xb}"
+  by (import hollight NUMSEG_ADD_SPLIT)
+
+lemma SUBSET_NUMSEG: "({m::nat..n::nat} <= {p::nat..q::nat}) = (n < m | p <= m & n <= q)"
+  by (import hollight SUBSET_NUMSEG)
+
+lemma NUMSEG_LE: "{u::nat. EX xa<=x::nat. u = xa} = {0::nat..x}"
+  by (import hollight NUMSEG_LE)
+
+lemma NUMSEG_LT: "{u::nat. EX x<n::nat. u = x} =
+(if n = (0::nat) then {} else {0::nat..n - (1::nat)})"
+  by (import hollight NUMSEG_LT)
+
+lemma TOPOLOGICAL_SORT: "[| (ALL (x::'A) y::'A.
+       (u_556::'A => 'A => bool) x y & u_556 y x --> x = y) &
+   (ALL (x::'A) (y::'A) z::'A. u_556 x y & u_556 y z --> u_556 x z);
+   HAS_SIZE (s::'A => bool) (n::nat) |]
+==> EX f::nat => 'A.
+       s = f ` {1::nat..n} &
+       (ALL (j::nat) k::nat.
+           j : {1::nat..n} & k : {1::nat..n} & j < k -->
+           ~ u_556 (f k) (f j))"
+  by (import hollight TOPOLOGICAL_SORT)
+
+lemma FINITE_INTSEG: "(ALL l r. finite {u. EX x. (int_le l x & int_le x r) & u = x}) &
+(ALL l r. finite {u. EX x. (int_le l x & int_lt x r) & u = x}) &
+(ALL l r. finite {u. EX x. (int_lt l x & int_le x r) & u = x}) &
+(ALL l r. finite {u. EX x. (int_lt l x & int_lt x r) & u = x})"
+  by (import hollight FINITE_INTSEG)
+
+definition
+  neutral :: "('q_59899 => 'q_59899 => 'q_59899) => 'q_59899"  where
+  "neutral ==
+%u::'q_59899 => 'q_59899 => 'q_59899.
+   SOME x::'q_59899. ALL y::'q_59899. u x y = y & u y x = y"
+
+lemma DEF_neutral: "neutral =
+(%u::'q_59899 => 'q_59899 => 'q_59899.
+    SOME x::'q_59899. ALL y::'q_59899. u x y = y & u y x = y)"
+  by (import hollight DEF_neutral)
+
+definition
+  monoidal :: "('A => 'A => 'A) => bool"  where
+  "monoidal ==
+%u::'A => 'A => 'A.
+   (ALL (x::'A) y::'A. u x y = u y x) &
+   (ALL (x::'A) (y::'A) z::'A. u x (u y z) = u (u x y) z) &
+   (ALL x::'A. u (neutral u) x = x)"
+
+lemma DEF_monoidal: "monoidal =
+(%u::'A => 'A => 'A.
+    (ALL (x::'A) y::'A. u x y = u y x) &
+    (ALL (x::'A) (y::'A) z::'A. u x (u y z) = u (u x y) z) &
+    (ALL x::'A. u (neutral u) x = x))"
+  by (import hollight DEF_monoidal)
+
+lemma MONOIDAL_AC: "monoidal (x::'q_60055 => 'q_60055 => 'q_60055)
+==> (ALL a::'q_60055. x (neutral x) a = a) &
+    (ALL a::'q_60055. x a (neutral x) = a) &
+    (ALL (a::'q_60055) b::'q_60055. x a b = x b a) &
+    (ALL (a::'q_60055) (b::'q_60055) c::'q_60055.
+        x (x a b) c = x a (x b c)) &
+    (ALL (a::'q_60055) (b::'q_60055) c::'q_60055. x a (x b c) = x b (x a c))"
+  by (import hollight MONOIDAL_AC)
+
+definition
+  support :: "('B => 'B => 'B) => ('A => 'B) => ('A => bool) => 'A => bool"  where
+  "support ==
+%(u::'B => 'B => 'B) (ua::'A => 'B) ub::'A => bool.
+   {uc::'A. EX x::'A. (x : ub & ua x ~= neutral u) & uc = x}"
+
+lemma DEF_support: "support =
+(%(u::'B => 'B => 'B) (ua::'A => 'B) ub::'A => bool.
+    {uc::'A. EX x::'A. (x : ub & ua x ~= neutral u) & uc = x})"
+  by (import hollight DEF_support)
+
+definition
+  iterate :: "('q_60113 => 'q_60113 => 'q_60113)
+=> ('A => bool) => ('A => 'q_60113) => 'q_60113"  where
+  "iterate ==
+%(u::'q_60113 => 'q_60113 => 'q_60113) (ua::'A => bool) ub::'A => 'q_60113.
+   if finite (support u ub ua)
+   then ITSET (%x::'A. u (ub x)) (support u ub ua) (neutral u)
+   else neutral u"
+
+lemma DEF_iterate: "iterate =
+(%(u::'q_60113 => 'q_60113 => 'q_60113) (ua::'A => bool) ub::'A => 'q_60113.
+    if finite (support u ub ua)
+    then ITSET (%x::'A. u (ub x)) (support u ub ua) (neutral u)
+    else neutral u)"
+  by (import hollight DEF_iterate)
+
+lemma IN_SUPPORT: "((xb::'q_60163)
+ : support (x::'q_60160 => 'q_60160 => 'q_60160) (xa::'q_60163 => 'q_60160)
+    (xc::'q_60163 => bool)) =
+(xb : xc & xa xb ~= neutral x)"
+  by (import hollight IN_SUPPORT)
+
+lemma SUPPORT_SUPPORT: "support (x::'q_60185 => 'q_60185 => 'q_60185) (xa::'q_60196 => 'q_60185)
+ (support x xa (xb::'q_60196 => bool)) =
+support x xa xb"
+  by (import hollight SUPPORT_SUPPORT)
+
+lemma SUPPORT_EMPTY: "(ALL xc::'q_60235.
+    xc : (xb::'q_60235 => bool) -->
+    (xa::'q_60235 => 'q_60221) xc =
+    neutral (x::'q_60221 => 'q_60221 => 'q_60221)) =
+(support x xa xb = {})"
+  by (import hollight SUPPORT_EMPTY)
+
+lemma SUPPORT_SUBSET: "support (x::'q_60255 => 'q_60255 => 'q_60255) (xa::'q_60256 => 'q_60255)
+ (xb::'q_60256 => bool)
+<= xb"
+  by (import hollight SUPPORT_SUBSET)
+
+lemma FINITE_SUPPORT: "finite (s::'q_60273 => bool)
+==> finite
+     (support (u::'q_60279 => 'q_60279 => 'q_60279)
+       (f::'q_60273 => 'q_60279) s)"
+  by (import hollight FINITE_SUPPORT)
+
+lemma SUPPORT_CLAUSES: "(ALL x::'q_60297 => 'q_60530.
+    support (u_4371::'q_60530 => 'q_60530 => 'q_60530) x {} = {}) &
+(ALL (x::'q_60345 => 'q_60530) (xa::'q_60345) xb::'q_60345 => bool.
+    support u_4371 x (insert xa xb) =
+    (if x xa = neutral u_4371 then support u_4371 x xb
+     else insert xa (support u_4371 x xb))) &
+(ALL (x::'q_60378 => 'q_60530) (xa::'q_60378) xb::'q_60378 => bool.
+    support u_4371 x (xb - {xa}) = support u_4371 x xb - {xa}) &
+(ALL (x::'q_60416 => 'q_60530) (xa::'q_60416 => bool) xb::'q_60416 => bool.
+    support u_4371 x (xa Un xb) =
+    support u_4371 x xa Un support u_4371 x xb) &
+(ALL (x::'q_60454 => 'q_60530) (xa::'q_60454 => bool) xb::'q_60454 => bool.
+    support u_4371 x (xa Int xb) =
+    support u_4371 x xa Int support u_4371 x xb) &
+(ALL (x::'q_60492 => 'q_60530) (xa::'q_60492 => bool) xb::'q_60492 => bool.
+    support u_4371 x (xa - xb) =
+    support u_4371 x xa - support u_4371 x xb) &
+(ALL (x::'q_60529 => 'q_60520) (xa::'q_60520 => 'q_60530)
+    xb::'q_60529 => bool.
+    support u_4371 xa (x ` xb) = x ` support u_4371 (xa o x) xb)"
+  by (import hollight SUPPORT_CLAUSES)
+
+lemma SUPPORT_DELTA: "support (x::'q_60556 => 'q_60556 => 'q_60556)
+ (%xa::'q_60584.
+     if xa = (xc::'q_60584) then (xb::'q_60584 => 'q_60556) xa
+     else neutral x)
+ (xa::'q_60584 => bool) =
+(if xc : xa then support x xb {xc} else {})"
+  by (import hollight SUPPORT_DELTA)
+
+lemma FINITE_SUPPORT_DELTA: "finite
+ (support (x::'q_60605 => 'q_60605 => 'q_60605)
+   (%xc::'q_60614.
+       if xc = (xb::'q_60614) then (xa::'q_60614 => 'q_60605) xc
+       else neutral x)
+   (s::'q_60614 => bool))"
+  by (import hollight FINITE_SUPPORT_DELTA)
+
+lemma ITERATE_SUPPORT: "iterate (x::'q_60630 => 'q_60630 => 'q_60630)
+ (support x (xa::'q_60642 => 'q_60630) (xb::'q_60642 => bool)) xa =
+iterate x xb xa"
+  by (import hollight ITERATE_SUPPORT)
+
+lemma ITERATE_EXPAND_CASES: "iterate (x::'q_60661 => 'q_60661 => 'q_60661) (xb::'q_60667 => bool)
+ (xa::'q_60667 => 'q_60661) =
+(if finite (support x xa xb) then iterate x (support x xa xb) xa
+ else neutral x)"
+  by (import hollight ITERATE_EXPAND_CASES)
+
+lemma ITERATE_CLAUSES_GEN: "monoidal (u_4371::'B => 'B => 'B)
+==> (ALL f::'A => 'B. iterate u_4371 {} f = neutral u_4371) &
+    (ALL (f::'A => 'B) (x::'A) s::'A => bool.
+        monoidal u_4371 & finite (support u_4371 f s) -->
+        iterate u_4371 (insert x s) f =
+        (if x : s then iterate u_4371 s f
+         else u_4371 (f x) (iterate u_4371 s f)))"
+  by (import hollight ITERATE_CLAUSES_GEN)
+
+lemma ITERATE_CLAUSES: "monoidal (x::'q_60857 => 'q_60857 => 'q_60857)
+==> (ALL f::'q_60815 => 'q_60857. iterate x {} f = neutral x) &
+    (ALL (f::'q_60859 => 'q_60857) (xa::'q_60859) s::'q_60859 => bool.
+        finite s -->
+        iterate x (insert xa s) f =
+        (if xa : s then iterate x s f else x (f xa) (iterate x s f)))"
+  by (import hollight ITERATE_CLAUSES)
+
+lemma ITERATE_UNION: "[| monoidal (u_4371::'q_60945 => 'q_60945 => 'q_60945);
+   finite (s::'q_60930 => bool) &
+   finite (x::'q_60930 => bool) & s Int x = {} |]
+==> iterate u_4371 (s Un x) (f::'q_60930 => 'q_60945) =
+    u_4371 (iterate u_4371 s f) (iterate u_4371 x f)"
+  by (import hollight ITERATE_UNION)
+
+lemma ITERATE_UNION_GEN: "[| monoidal (x::'B => 'B => 'B);
+   finite (support x (xa::'A => 'B) (xb::'A => bool)) &
+   finite (support x xa (xc::'A => bool)) &
+   support x xa xb Int support x xa xc = {} |]
+==> iterate x (xb Un xc) xa = x (iterate x xb xa) (iterate x xc xa)"
+  by (import hollight ITERATE_UNION_GEN)
+
+lemma ITERATE_DIFF: "[| monoidal (u::'q_61087 => 'q_61087 => 'q_61087);
+   finite (s::'q_61083 => bool) & (t::'q_61083 => bool) <= s |]
+==> u (iterate u (s - t) (f::'q_61083 => 'q_61087)) (iterate u t f) =
+    iterate u s f"
+  by (import hollight ITERATE_DIFF)
+
+lemma ITERATE_DIFF_GEN: "[| monoidal (x::'B => 'B => 'B);
+   finite (support x (xa::'A => 'B) (xb::'A => bool)) &
+   support x xa (xc::'A => bool) <= support x xa xb |]
+==> x (iterate x (xb - xc) xa) (iterate x xc xa) = iterate x xb xa"
+  by (import hollight ITERATE_DIFF_GEN)
+
+lemma ITERATE_INCL_EXCL: "[| monoidal (u_4371::'q_61316 => 'q_61316 => 'q_61316);
+   finite (s::'q_61298 => bool) & finite (t::'q_61298 => bool) |]
+==> u_4371 (iterate u_4371 s (f::'q_61298 => 'q_61316))
+     (iterate u_4371 t f) =
+    u_4371 (iterate u_4371 (s Un t) f) (iterate u_4371 (s Int t) f)"
+  by (import hollight ITERATE_INCL_EXCL)
+
+lemma ITERATE_CLOSED: "[| monoidal (u_4371::'B => 'B => 'B);
+   (P::'B => bool) (neutral u_4371) &
+   (ALL (x::'B) y::'B. P x & P y --> P (u_4371 x y));
+   !!x::'A.
+      x : (s::'A => bool) & (f::'A => 'B) x ~= neutral u_4371 ==> P (f x) |]
+==> P (iterate u_4371 s f)"
+  by (import hollight ITERATE_CLOSED)
+
+lemma ITERATE_RELATED: "[| monoidal (u_4371::'B => 'B => 'B);
+   (R::'B => 'B => bool) (neutral u_4371) (neutral u_4371) &
+   (ALL (x1::'B) (y1::'B) (x2::'B) y2::'B.
+       R x1 x2 & R y1 y2 --> R (u_4371 x1 y1) (u_4371 x2 y2));
+   finite (x::'A => bool) &
+   (ALL xa::'A. xa : x --> R ((f::'A => 'B) xa) ((g::'A => 'B) xa)) |]
+==> R (iterate u_4371 x f) (iterate u_4371 x g)"
+  by (import hollight ITERATE_RELATED)
+
+lemma ITERATE_EQ_NEUTRAL: "[| monoidal (u_4371::'B => 'B => 'B);
+   !!x::'A. x : (s::'A => bool) ==> (f::'A => 'B) x = neutral u_4371 |]
+==> iterate u_4371 s f = neutral u_4371"
+  by (import hollight ITERATE_EQ_NEUTRAL)
+
+lemma ITERATE_SING: "monoidal (x::'B => 'B => 'B) ==> iterate x {xa::'A} (f::'A => 'B) = f xa"
+  by (import hollight ITERATE_SING)
+
+lemma ITERATE_DELETE: "[| monoidal (u::'B => 'B => 'B); finite (s::'A => bool) & (a::'A) : s |]
+==> u ((f::'A => 'B) a) (iterate u (s - {a}) f) = iterate u s f"
+  by (import hollight ITERATE_DELETE)
+
+lemma ITERATE_DELTA: "monoidal (u_4371::'q_61672 => 'q_61672 => 'q_61672)
+==> iterate u_4371 (xb::'q_61691 => bool)
+     (%xb::'q_61691.
+         if xb = (xa::'q_61691) then (x::'q_61691 => 'q_61672) xb
+         else neutral u_4371) =
+    (if xa : xb then x xa else neutral u_4371)"
+  by (import hollight ITERATE_DELTA)
+
+lemma ITERATE_IMAGE: "[| monoidal (u_4371::'C => 'C => 'C);
+   !!(x::'A) y::'A.
+      x : (s::'A => bool) & y : s & (f::'A => 'B) x = f y ==> x = y |]
+==> iterate u_4371 (f ` s) (g::'B => 'C) = iterate u_4371 s (g o f)"
+  by (import hollight ITERATE_IMAGE)
+
+lemma ITERATE_BIJECTION: "[| monoidal (u_4371::'B => 'B => 'B);
+   (ALL x::'A. x : (s::'A => bool) --> (p::'A => 'A) x : s) &
+   (ALL y::'A. y : s --> (EX! x::'A. x : s & p x = y)) |]
+==> iterate u_4371 s (f::'A => 'B) = iterate u_4371 s (f o p)"
+  by (import hollight ITERATE_BIJECTION)
+
+lemma ITERATE_ITERATE_PRODUCT: "[| monoidal (u_4371::'C => 'C => 'C);
+   finite (x::'A => bool) &
+   (ALL i::'A. i : x --> finite ((xa::'A => 'B => bool) i)) |]
+==> iterate u_4371 x
+     (%i::'A. iterate u_4371 (xa i) ((xb::'A => 'B => 'C) i)) =
+    iterate u_4371
+     {u::'A * 'B. EX (i::'A) j::'B. (i : x & j : xa i) & u = (i, j)}
+     (SOME f::'A * 'B => 'C. ALL (i::'A) j::'B. f (i, j) = xb i j)"
+  by (import hollight ITERATE_ITERATE_PRODUCT)
+
+lemma ITERATE_EQ: "[| monoidal (u_4371::'B => 'B => 'B);
+   !!x::'A. x : (s::'A => bool) ==> (f::'A => 'B) x = (g::'A => 'B) x |]
+==> iterate u_4371 s f = iterate u_4371 s g"
+  by (import hollight ITERATE_EQ)
+
+lemma ITERATE_EQ_GENERAL: "[| monoidal (u_4371::'C => 'C => 'C);
+   (ALL y::'B.
+       y : (t::'B => bool) -->
+       (EX! x::'A. x : (s::'A => bool) & (h::'A => 'B) x = y)) &
+   (ALL x::'A. x : s --> h x : t & (g::'B => 'C) (h x) = (f::'A => 'C) x) |]
+==> iterate u_4371 s f = iterate u_4371 t g"
+  by (import hollight ITERATE_EQ_GENERAL)
+
+lemma ITERATE_EQ_GENERAL_INVERSES: "[| monoidal (u_4371::'C => 'C => 'C);
+   (ALL y::'B.
+       y : (t::'B => bool) -->
+       (k::'B => 'A) y : (s::'A => bool) & (h::'A => 'B) (k y) = y) &
+   (ALL x::'A.
+       x : s -->
+       h x : t & k (h x) = x & (g::'B => 'C) (h x) = (f::'A => 'C) x) |]
+==> iterate u_4371 s f = iterate u_4371 t g"
+  by (import hollight ITERATE_EQ_GENERAL_INVERSES)
+
+lemma ITERATE_INJECTION: "[| monoidal (u_4371::'B => 'B => 'B);
+   finite (s::'A => bool) &
+   (ALL x::'A. x : s --> (p::'A => 'A) x : s) &
+   (ALL (x::'A) y::'A. x : s & y : s & p x = p y --> x = y) |]
+==> iterate u_4371 s ((f::'A => 'B) o p) = iterate u_4371 s f"
+  by (import hollight ITERATE_INJECTION)
+
+lemma ITERATE_UNION_NONZERO: "[| monoidal (u_4371::'B => 'B => 'B);
+   finite (s::'A => bool) &
+   finite (t::'A => bool) &
+   (ALL x::'A. x : s Int t --> (f::'A => 'B) x = neutral u_4371) |]
+==> iterate u_4371 (s Un t) f =
+    u_4371 (iterate u_4371 s f) (iterate u_4371 t f)"
+  by (import hollight ITERATE_UNION_NONZERO)
+
+lemma ITERATE_OP: "[| monoidal (u_4371::'q_62649 => 'q_62649 => 'q_62649);
+   finite (s::'q_62648 => bool) |]
+==> iterate u_4371 s
+     (%x::'q_62648.
+         u_4371 ((f::'q_62648 => 'q_62649) x)
+          ((g::'q_62648 => 'q_62649) x)) =
+    u_4371 (iterate u_4371 s f) (iterate u_4371 s g)"
+  by (import hollight ITERATE_OP)
+
+lemma ITERATE_SUPERSET: "[| monoidal (u_4371::'B => 'B => 'B);
+   (u::'A => bool) <= (v::'A => bool) &
+   (ALL x::'A. x : v & x ~: u --> (f::'A => 'B) x = neutral u_4371) |]
+==> iterate u_4371 v f = iterate u_4371 u f"
+  by (import hollight ITERATE_SUPERSET)
+
+lemma ITERATE_IMAGE_NONZERO: "[| monoidal (u_4371::'C => 'C => 'C);
+   finite (x::'A => bool) &
+   (ALL (xa::'A) y::'A.
+       xa : x & y : x & xa ~= y & (f::'A => 'B) xa = f y -->
+       (g::'B => 'C) (f xa) = neutral u_4371) |]
+==> iterate u_4371 (f ` x) g = iterate u_4371 x (g o f)"
+  by (import hollight ITERATE_IMAGE_NONZERO)
+
+lemma ITERATE_CASES: "[| monoidal (u_4371::'B => 'B => 'B); finite (s::'A => bool) |]
+==> iterate u_4371 s
+     (%x::'A.
+         if (P::'A => bool) x then (f::'A => 'B) x else (g::'A => 'B) x) =
+    u_4371 (iterate u_4371 {u::'A. EX x::'A. (x : s & P x) & u = x} f)
+     (iterate u_4371 {u::'A. EX x::'A. (x : s & ~ P x) & u = x} g)"
+  by (import hollight ITERATE_CASES)
+
+lemma ITERATE_OP_GEN: "[| monoidal (u_4371::'B => 'B => 'B);
+   finite (support u_4371 (f::'A => 'B) (s::'A => bool)) &
+   finite (support u_4371 (g::'A => 'B) s) |]
+==> iterate u_4371 s (%x::'A. u_4371 (f x) (g x)) =
+    u_4371 (iterate u_4371 s f) (iterate u_4371 s g)"
+  by (import hollight ITERATE_OP_GEN)
+
+lemma ITERATE_CLAUSES_NUMSEG: "monoidal (x::'q_63246 => 'q_63246 => 'q_63246)
+==> (ALL xa::nat.
+        iterate x {xa..0::nat} (f::nat => 'q_63246) =
+        (if xa = (0::nat) then f (0::nat) else neutral x)) &
+    (ALL (xa::nat) xb::nat.
+        iterate x {xa..Suc xb} f =
+        (if xa <= Suc xb then x (iterate x {xa..xb} f) (f (Suc xb))
+         else iterate x {xa..xb} f))"
+  by (import hollight ITERATE_CLAUSES_NUMSEG)
+
+lemma ITERATE_PAIR: "monoidal (u_4371::'q_63421 => 'q_63421 => 'q_63421)
+==> iterate u_4371 {(2::nat) * (m::nat)..(2::nat) * (n::nat) + (1::nat)}
+     (f::nat => 'q_63421) =
+    iterate u_4371 {m..n}
+     (%i::nat. u_4371 (f ((2::nat) * i)) (f ((2::nat) * i + (1::nat))))"
+  by (import hollight ITERATE_PAIR)
+
+definition
+  nsum :: "('q_63439 => bool) => ('q_63439 => nat) => nat"  where
+  "(op ==::(('q_63439::type => bool) => ('q_63439::type => nat) => nat)
+        => (('q_63439::type => bool) => ('q_63439::type => nat) => nat)
+           => prop)
+ (nsum::('q_63439::type => bool) => ('q_63439::type => nat) => nat)
+ ((iterate::(nat => nat => nat)
+            => ('q_63439::type => bool) => ('q_63439::type => nat) => nat)
+   (op +::nat => nat => nat))"
+
+lemma DEF_nsum: "(op =::(('q_63439::type => bool) => ('q_63439::type => nat) => nat)
+       => (('q_63439::type => bool) => ('q_63439::type => nat) => nat)
+          => bool)
+ (nsum::('q_63439::type => bool) => ('q_63439::type => nat) => nat)
+ ((iterate::(nat => nat => nat)
+            => ('q_63439::type => bool) => ('q_63439::type => nat) => nat)
+   (op +::nat => nat => nat))"
+  by (import hollight DEF_nsum)
+
+lemma NEUTRAL_ADD: "neutral op + = (0::nat)"
+  by (import hollight NEUTRAL_ADD)
+
+lemma NEUTRAL_MUL: "neutral op * = (1::nat)"
+  by (import hollight NEUTRAL_MUL)
+
+lemma MONOIDAL_ADD: "(monoidal::(nat => nat => nat) => bool) (op +::nat => nat => nat)"
+  by (import hollight MONOIDAL_ADD)
+
+lemma MONOIDAL_MUL: "(monoidal::(nat => nat => nat) => bool) (op *::nat => nat => nat)"
+  by (import hollight MONOIDAL_MUL)
+
+lemma NSUM_CLAUSES: "(ALL x::'q_63477 => nat. nsum {} x = (0::nat)) &
+(ALL (x::'q_63516) (xa::'q_63516 => nat) xb::'q_63516 => bool.
+    finite xb -->
+    nsum (insert x xb) xa =
+    (if x : xb then nsum xb xa else xa x + nsum xb xa))"
+  by (import hollight NSUM_CLAUSES)
+
+lemma NSUM_UNION: "finite (xa::'q_63542 => bool) &
+finite (xb::'q_63542 => bool) & xa Int xb = {}
+==> nsum (xa Un xb) (x::'q_63542 => nat) = nsum xa x + nsum xb x"
+  by (import hollight NSUM_UNION)
+
+lemma NSUM_DIFF: "finite (s::'q_63597 => bool) & (t::'q_63597 => bool) <= s
+==> nsum (s - t) (f::'q_63597 => nat) = nsum s f - nsum t f"
+  by (import hollight NSUM_DIFF)
+
+lemma NSUM_INCL_EXCL: "finite (x::'A => bool) & finite (xa::'A => bool)
+==> nsum x (xb::'A => nat) + nsum xa xb =
+    nsum (x Un xa) xb + nsum (x Int xa) xb"
+  by (import hollight NSUM_INCL_EXCL)
+
+lemma NSUM_SUPPORT: "nsum (support op + (x::'q_63686 => nat) (xa::'q_63686 => bool)) x =
+nsum xa x"
+  by (import hollight NSUM_SUPPORT)
+
+lemma NSUM_ADD: "finite (xb::'q_63720 => bool)
+==> nsum xb
+     (%xb::'q_63720. (x::'q_63720 => nat) xb + (xa::'q_63720 => nat) xb) =
+    nsum xb x + nsum xb xa"
+  by (import hollight NSUM_ADD)
+
+lemma NSUM_ADD_GEN: "finite
+ {xa::'q_63807.
+  EX xc::'q_63807.
+     (xc : (xb::'q_63807 => bool) & (x::'q_63807 => nat) xc ~= (0::nat)) &
+     xa = xc} &
+finite
+ {x::'q_63807.
+  EX xc::'q_63807.
+     (xc : xb & (xa::'q_63807 => nat) xc ~= (0::nat)) & x = xc}
+==> nsum xb (%xb::'q_63807. x xb + xa xb) = nsum xb x + nsum xb xa"
+  by (import hollight NSUM_ADD_GEN)
+
+lemma NSUM_EQ_0: "(!!xb::'A. xb : (xa::'A => bool) ==> (x::'A => nat) xb = (0::nat))
+==> nsum xa x = (0::nat)"
+  by (import hollight NSUM_EQ_0)
+
+lemma NSUM_0: "nsum (x::'A => bool) (%n::'A. 0::nat) = (0::nat)"
+  by (import hollight NSUM_0)
+
+lemma NSUM_LMUL: "nsum (s::'A => bool) (%x::'A. (c::nat) * (f::'A => nat) x) = c * nsum s f"
+  by (import hollight NSUM_LMUL)
+
+lemma NSUM_RMUL: "nsum (xb::'A => bool) (%xb::'A. (x::'A => nat) xb * (xa::nat)) =
+nsum xb x * xa"
+  by (import hollight NSUM_RMUL)
+
+lemma NSUM_LE: "finite (xb::'q_63997 => bool) &
+(ALL xc::'q_63997.
+    xc : xb --> (x::'q_63997 => nat) xc <= (xa::'q_63997 => nat) xc)
+==> nsum xb x <= nsum xb xa"
+  by (import hollight NSUM_LE)
+
+lemma NSUM_LT: "finite (s::'A => bool) &
+(ALL x::'A. x : s --> (f::'A => nat) x <= (g::'A => nat) x) &
+(EX x::'A. x : s & f x < g x)
+==> nsum s f < nsum s g"
+  by (import hollight NSUM_LT)
+
+lemma NSUM_LT_ALL: "finite (s::'q_64119 => bool) &
+s ~= {} &
+(ALL x::'q_64119. x : s --> (f::'q_64119 => nat) x < (g::'q_64119 => nat) x)
+==> nsum s f < nsum s g"
+  by (import hollight NSUM_LT_ALL)
+
+lemma NSUM_EQ: "(!!xc::'q_64157.
+    xc : (xb::'q_64157 => bool)
+    ==> (x::'q_64157 => nat) xc = (xa::'q_64157 => nat) xc)
+==> nsum xb x = nsum xb xa"
+  by (import hollight NSUM_EQ)
+
+lemma NSUM_CONST: "finite (s::'q_64187 => bool) ==> nsum s (%n::'q_64187. c::nat) = CARD s * c"
+  by (import hollight NSUM_CONST)
+
+lemma NSUM_POS_BOUND: "[| finite (x::'A => bool) & nsum x (f::'A => nat) <= (b::nat);
+   (xa::'A) : x |]
+==> f xa <= b"
+  by (import hollight NSUM_POS_BOUND)
+
+lemma NSUM_EQ_0_IFF: "finite (s::'q_64296 => bool)
+==> (nsum s (f::'q_64296 => nat) = (0::nat)) =
+    (ALL x::'q_64296. x : s --> f x = (0::nat))"
+  by (import hollight NSUM_EQ_0_IFF)
+
+lemma NSUM_DELETE: "finite (xa::'q_64325 => bool) & (xb::'q_64325) : xa
+==> (x::'q_64325 => nat) xb + nsum (xa - {xb}) x = nsum xa x"
+  by (import hollight NSUM_DELETE)
+
+lemma NSUM_SING: "nsum {xa::'q_64354} (x::'q_64354 => nat) = x xa"
+  by (import hollight NSUM_SING)
+
+lemma NSUM_DELTA: "nsum (x::'A => bool) (%x::'A. if x = (xa::'A) then b::nat else (0::nat)) =
+(if xa : x then b else (0::nat))"
+  by (import hollight NSUM_DELTA)
+
+lemma NSUM_SWAP: "finite (x::'A => bool) & finite (xa::'B => bool)
+==> nsum x (%i::'A. nsum xa ((f::'A => 'B => nat) i)) =
+    nsum xa (%j::'B. nsum x (%i::'A. f i j))"
+  by (import hollight NSUM_SWAP)
+
+lemma NSUM_IMAGE: "(!!(xa::'q_64490) y::'q_64490.
+    xa : (xb::'q_64490 => bool) &
+    y : xb & (x::'q_64490 => 'q_64466) xa = x y
+    ==> xa = y)
+==> nsum (x ` xb) (xa::'q_64466 => nat) = nsum xb (xa o x)"
+  by (import hollight NSUM_IMAGE)
+
+lemma NSUM_SUPERSET: "(xa::'A => bool) <= (xb::'A => bool) &
+(ALL xc::'A. xc : xb & xc ~: xa --> (x::'A => nat) xc = (0::nat))
+==> nsum xb x = nsum xa x"
+  by (import hollight NSUM_SUPERSET)
+
+lemma NSUM_UNION_RZERO: "finite (u::'A => bool) &
+(ALL x::'A. x : (v::'A => bool) & x ~: u --> (f::'A => nat) x = (0::nat))
+==> nsum (u Un v) f = nsum u f"
+  by (import hollight NSUM_UNION_RZERO)
+
+lemma NSUM_UNION_LZERO: "finite (v::'A => bool) &
+(ALL x::'A. x : (u::'A => bool) & x ~: v --> (f::'A => nat) x = (0::nat))
+==> nsum (u Un v) f = nsum v f"
+  by (import hollight NSUM_UNION_LZERO)
+
+lemma NSUM_RESTRICT: "finite (s::'q_64681 => bool)
+==> nsum s
+     (%x::'q_64681. if x : s then (f::'q_64681 => nat) x else (0::nat)) =
+    nsum s f"
+  by (import hollight NSUM_RESTRICT)
+
+lemma NSUM_BOUND: "finite (x::'A => bool) &
+(ALL xc::'A. xc : x --> (xa::'A => nat) xc <= (xb::nat))
+==> nsum x xa <= CARD x * xb"
+  by (import hollight NSUM_BOUND)
+
+lemma NSUM_BOUND_GEN: "finite (x::'A => bool) &
+x ~= {} & (ALL xa::'A. xa : x --> (f::'A => nat) xa <= (b::nat) div CARD x)
+==> nsum x f <= b"
+  by (import hollight NSUM_BOUND_GEN)
+
+lemma NSUM_BOUND_LT: "finite (s::'A => bool) &
+(ALL x::'A. x : s --> (f::'A => nat) x <= (b::nat)) &
+(EX x::'A. x : s & f x < b)
+==> nsum s f < CARD s * b"
+  by (import hollight NSUM_BOUND_LT)
+
+lemma NSUM_BOUND_LT_ALL: "finite (s::'q_64899 => bool) &
+s ~= {} & (ALL x::'q_64899. x : s --> (f::'q_64899 => nat) x < (b::nat))
+==> nsum s f < CARD s * b"
+  by (import hollight NSUM_BOUND_LT_ALL)
+
+lemma NSUM_BOUND_LT_GEN: "finite (s::'A => bool) &
+s ~= {} & (ALL x::'A. x : s --> (f::'A => nat) x < (b::nat) div CARD s)
+==> nsum s f < b"
+  by (import hollight NSUM_BOUND_LT_GEN)
+
+lemma NSUM_UNION_EQ: "finite (u::'q_65000 => bool) &
+(s::'q_65000 => bool) Int (t::'q_65000 => bool) = {} & s Un t = u
+==> nsum s (f::'q_65000 => nat) + nsum t f = nsum u f"
+  by (import hollight NSUM_UNION_EQ)
+
+lemma NSUM_EQ_SUPERSET: "finite (t::'A => bool) &
+t <= (s::'A => bool) &
+(ALL x::'A. x : t --> (f::'A => nat) x = (g::'A => nat) x) &
+(ALL x::'A. x : s & x ~: t --> f x = (0::nat))
+==> nsum s f = nsum t g"
+  by (import hollight NSUM_EQ_SUPERSET)
+
+lemma NSUM_RESTRICT_SET: "nsum
+ {u::'A. EX xb::'A. (xb : (xa::'A => bool) & (x::'A => bool) xb) & u = xb}
+ (xb::'A => nat) =
+nsum xa (%xa::'A. if x xa then xb xa else (0::nat))"
+  by (import hollight NSUM_RESTRICT_SET)
+
+lemma NSUM_NSUM_RESTRICT: "finite (s::'q_65257 => bool) & finite (t::'q_65256 => bool)
+==> nsum s
+     (%x::'q_65257.
+         nsum
+          {u::'q_65256.
+           EX y::'q_65256.
+              (y : t & (R::'q_65257 => 'q_65256 => bool) x y) & u = y}
+          ((f::'q_65257 => 'q_65256 => nat) x)) =
+    nsum t
+     (%y::'q_65256.
+         nsum {u::'q_65257. EX x::'q_65257. (x : s & R x y) & u = x}
+          (%x::'q_65257. f x y))"
+  by (import hollight NSUM_NSUM_RESTRICT)
+
+lemma CARD_EQ_NSUM: "finite (x::'q_65276 => bool) ==> CARD x = nsum x (%x::'q_65276. 1::nat)"
+  by (import hollight CARD_EQ_NSUM)
+
+lemma NSUM_MULTICOUNT_GEN: "finite (s::'A => bool) &
+finite (t::'B => bool) &
+(ALL j::'B.
+    j : t -->
+    CARD {u::'A. EX i::'A. (i : s & (R::'A => 'B => bool) i j) & u = i} =
+    (k::'B => nat) j)
+==> nsum s (%i::'A. CARD {u::'B. EX j::'B. (j : t & R i j) & u = j}) =
+    nsum t k"
+  by (import hollight NSUM_MULTICOUNT_GEN)
+
+lemma NSUM_MULTICOUNT: "finite (s::'A => bool) &
+finite (t::'B => bool) &
+(ALL j::'B.
+    j : t -->
+    CARD {u::'A. EX i::'A. (i : s & (R::'A => 'B => bool) i j) & u = i} =
+    (k::nat))
+==> nsum s (%i::'A. CARD {u::'B. EX j::'B. (j : t & R i j) & u = j}) =
+    k * CARD t"
+  by (import hollight NSUM_MULTICOUNT)
+
+lemma NSUM_IMAGE_GEN: "finite (s::'A => bool)
+==> nsum s (g::'A => nat) =
+    nsum ((f::'A => 'B) ` s)
+     (%y::'B. nsum {u::'A. EX x::'A. (x : s & f x = y) & u = x} g)"
+  by (import hollight NSUM_IMAGE_GEN)
+
+lemma NSUM_GROUP: "finite (s::'A => bool) & (f::'A => 'B) ` s <= (t::'B => bool)
+==> nsum t
+     (%y::'B.
+         nsum {u::'A. EX x::'A. (x : s & f x = y) & u = x} (g::'A => nat)) =
+    nsum s g"
+  by (import hollight NSUM_GROUP)
+
+lemma NSUM_SUBSET: "finite (u::'A => bool) &
+finite (v::'A => bool) &
+(ALL x::'A. x : u - v --> (f::'A => nat) x = (0::nat))
+==> nsum u f <= nsum v f"
+  by (import hollight NSUM_SUBSET)
+
+lemma NSUM_SUBSET_SIMPLE: "finite (v::'q_65804 => bool) & (u::'q_65804 => bool) <= v
+==> nsum u (f::'q_65804 => nat) <= nsum v f"
+  by (import hollight NSUM_SUBSET_SIMPLE)
+
+lemma NSUM_IMAGE_NONZERO: "finite (xb::'A => bool) &
+(ALL (xc::'A) xd::'A.
+    xc : xb & xd : xb & xc ~= xd & (xa::'A => 'B) xc = xa xd -->
+    (x::'B => nat) (xa xc) = (0::nat))
+==> nsum (xa ` xb) x = nsum xb (x o xa)"
+  by (import hollight NSUM_IMAGE_NONZERO)
+
+lemma NSUM_BIJECTION: "(ALL x::'A. x : (xb::'A => bool) --> (xa::'A => 'A) x : xb) &
+(ALL y::'A. y : xb --> (EX! x::'A. x : xb & xa x = y))
+==> nsum xb (x::'A => nat) = nsum xb (x o xa)"
+  by (import hollight NSUM_BIJECTION)
+
+lemma NSUM_NSUM_PRODUCT: "finite (x::'A => bool) &
+(ALL i::'A. i : x --> finite ((xa::'A => 'B => bool) i))
+==> nsum x (%x::'A. nsum (xa x) ((xb::'A => 'B => nat) x)) =
+    nsum {u::'A * 'B. EX (i::'A) j::'B. (i : x & j : xa i) & u = (i, j)}
+     (SOME f::'A * 'B => nat. ALL (i::'A) j::'B. f (i, j) = xb i j)"
+  by (import hollight NSUM_NSUM_PRODUCT)
+
+lemma NSUM_EQ_GENERAL: "(ALL y::'B.
+    y : (xa::'B => bool) -->
+    (EX! xa::'A. xa : (x::'A => bool) & (xd::'A => 'B) xa = y)) &
+(ALL xe::'A.
+    xe : x --> xd xe : xa & (xc::'B => nat) (xd xe) = (xb::'A => nat) xe)
+==> nsum x xb = nsum xa xc"
+  by (import hollight NSUM_EQ_GENERAL)
+
+lemma NSUM_EQ_GENERAL_INVERSES: "(ALL y::'B.
+    y : (xa::'B => bool) -->
+    (xe::'B => 'A) y : (x::'A => bool) & (xd::'A => 'B) (xe y) = y) &
+(ALL xf::'A.
+    xf : x -->
+    xd xf : xa &
+    xe (xd xf) = xf & (xc::'B => nat) (xd xf) = (xb::'A => nat) xf)
+==> nsum x xb = nsum xa xc"
+  by (import hollight NSUM_EQ_GENERAL_INVERSES)
+
+lemma NSUM_INJECTION: "finite (xb::'q_66274 => bool) &
+(ALL x::'q_66274. x : xb --> (xa::'q_66274 => 'q_66274) x : xb) &
+(ALL (x::'q_66274) y::'q_66274. x : xb & y : xb & xa x = xa y --> x = y)
+==> nsum xb ((x::'q_66274 => nat) o xa) = nsum xb x"
+  by (import hollight NSUM_INJECTION)
+
+lemma NSUM_UNION_NONZERO: "finite (xa::'q_66317 => bool) &
+finite (xb::'q_66317 => bool) &
+(ALL xc::'q_66317. xc : xa Int xb --> (x::'q_66317 => nat) xc = (0::nat))
+==> nsum (xa Un xb) x = nsum xa x + nsum xb x"
+  by (import hollight NSUM_UNION_NONZERO)
+
+lemma NSUM_UNIONS_NONZERO: "finite (x::('A => bool) => bool) &
+(ALL t::'A => bool. t : x --> finite t) &
+(ALL (t1::'A => bool) (t2::'A => bool) xa::'A.
+    t1 : x & t2 : x & t1 ~= t2 & xa : t1 & xa : t2 -->
+    (f::'A => nat) xa = (0::nat))
+==> nsum (Union x) f = nsum x (%t::'A => bool. nsum t f)"
+  by (import hollight NSUM_UNIONS_NONZERO)
+
+lemma NSUM_CASES: "finite (x::'A => bool)
+==> nsum x
+     (%x::'A.
+         if (xa::'A => bool) x then (xb::'A => nat) x
+         else (xc::'A => nat) x) =
+    nsum {u::'A. EX xb::'A. (xb : x & xa xb) & u = xb} xb +
+    nsum {u::'A. EX xb::'A. (xb : x & ~ xa xb) & u = xb} xc"
+  by (import hollight NSUM_CASES)
+
+lemma NSUM_CLOSED: "(P::nat => bool) (0::nat) &
+(ALL (x::nat) y::nat. P x & P y --> P (x + y)) &
+(ALL a::'A. a : (s::'A => bool) --> P ((f::'A => nat) a))
+==> P (nsum s f)"
+  by (import hollight NSUM_CLOSED)
+
+lemma NSUM_ADD_NUMSEG: "nsum {xb::nat..xc::nat} (%i::nat. (x::nat => nat) i + (xa::nat => nat) i) =
+nsum {xb..xc} x + nsum {xb..xc} xa"
+  by (import hollight NSUM_ADD_NUMSEG)
+
+lemma NSUM_LE_NUMSEG: "(!!i::nat.
+    (xb::nat) <= i & i <= (xc::nat)
+    ==> (x::nat => nat) i <= (xa::nat => nat) i)
+==> nsum {xb..xc} x <= nsum {xb..xc} xa"
+  by (import hollight NSUM_LE_NUMSEG)
+
+lemma NSUM_EQ_NUMSEG: "(!!i::nat.
+    (m::nat) <= i & i <= (n::nat) ==> (f::nat => nat) i = (g::nat => nat) i)
+==> nsum {m..n} f = nsum {m..n} g"
+  by (import hollight NSUM_EQ_NUMSEG)
+
+lemma NSUM_CONST_NUMSEG: "nsum {xa..xb} (%n. x) = (xb + 1 - xa) * x"
+  by (import hollight NSUM_CONST_NUMSEG)
+
+lemma NSUM_EQ_0_NUMSEG: "(!!i::nat. (m::nat) <= i & i <= (n::nat) ==> (x::nat => nat) i = (0::nat))
+==> nsum {m..n} x = (0::nat)"
+  by (import hollight NSUM_EQ_0_NUMSEG)
+
+lemma NSUM_EQ_0_IFF_NUMSEG: "(nsum {xa::nat..xb::nat} (x::nat => nat) = (0::nat)) =
+(ALL i::nat. xa <= i & i <= xb --> x i = (0::nat))"
+  by (import hollight NSUM_EQ_0_IFF_NUMSEG)
+
+lemma NSUM_TRIV_NUMSEG: "(n::nat) < (m::nat) ==> nsum {m..n} (f::nat => nat) = (0::nat)"
+  by (import hollight NSUM_TRIV_NUMSEG)
+
+lemma NSUM_SING_NUMSEG: "nsum {xa::nat..xa} (x::nat => nat) = x xa"
+  by (import hollight NSUM_SING_NUMSEG)
+
+lemma NSUM_CLAUSES_NUMSEG: "(ALL m. nsum {m..0} f = (if m = 0 then f 0 else 0)) &
+(ALL m n.
+    nsum {m..Suc n} f =
+    (if m <= Suc n then nsum {m..n} f + f (Suc n) else nsum {m..n} f))"
+  by (import hollight NSUM_CLAUSES_NUMSEG)
+
+lemma NSUM_SWAP_NUMSEG: "nsum {a::nat..b::nat}
+ (%i::nat. nsum {c::nat..d::nat} ((f::nat => nat => nat) i)) =
+nsum {c..d} (%j::nat. nsum {a..b} (%i::nat. f i j))"
+  by (import hollight NSUM_SWAP_NUMSEG)
+
+lemma NSUM_ADD_SPLIT: "(xa::nat) <= (xb::nat) + (1::nat)
+==> nsum {xa..xb + (xc::nat)} (x::nat => nat) =
+    nsum {xa..xb} x + nsum {xb + (1::nat)..xb + xc} x"
+  by (import hollight NSUM_ADD_SPLIT)
+
+lemma NSUM_OFFSET: "nsum {(xb::nat) + (x::nat)..(xc::nat) + x} (xa::nat => nat) =
+nsum {xb..xc} (%i::nat. xa (i + x))"
+  by (import hollight NSUM_OFFSET)
+
+lemma NSUM_OFFSET_0: "(xa::nat) <= (xb::nat)
+==> nsum {xa..xb} (x::nat => nat) =
+    nsum {0::nat..xb - xa} (%i::nat. x (i + xa))"
+  by (import hollight NSUM_OFFSET_0)
+
+lemma NSUM_CLAUSES_LEFT: "(xa::nat) <= (xb::nat)
+==> nsum {xa..xb} (x::nat => nat) = x xa + nsum {xa + (1::nat)..xb} x"
+  by (import hollight NSUM_CLAUSES_LEFT)
+
+lemma NSUM_CLAUSES_RIGHT: "(0::nat) < (n::nat) & (m::nat) <= n
+==> nsum {m..n} (f::nat => nat) = nsum {m..n - (1::nat)} f + f n"
+  by (import hollight NSUM_CLAUSES_RIGHT)
+
+lemma NSUM_PAIR: "nsum {(2::nat) * (m::nat)..(2::nat) * (n::nat) + (1::nat)} (f::nat => nat) =
+nsum {m..n} (%i::nat. f ((2::nat) * i) + f ((2::nat) * i + (1::nat)))"
+  by (import hollight NSUM_PAIR)
+
+lemma CARD_UNIONS: "finite (x::('A => bool) => bool) &
+(ALL t::'A => bool. t : x --> finite t) &
+(ALL (t::'A => bool) u::'A => bool. t : x & u : x & t ~= u --> t Int u = {})
+==> CARD (Union x) = nsum x CARD"
+  by (import hollight CARD_UNIONS)
+
+consts
+  sum :: "('q_67488 => bool) => ('q_67488 => hollight.real) => hollight.real" 
+
+defs
+  sum_def: "(op ==::(('q_67488::type => bool)
+         => ('q_67488::type => hollight.real) => hollight.real)
+        => (('q_67488::type => bool)
+            => ('q_67488::type => hollight.real) => hollight.real)
+           => prop)
+ (hollight.sum::('q_67488::type => bool)
+                => ('q_67488::type => hollight.real) => hollight.real)
+ ((iterate::(hollight.real => hollight.real => hollight.real)
+            => ('q_67488::type => bool)
+               => ('q_67488::type => hollight.real) => hollight.real)
+   (real_add::hollight.real => hollight.real => hollight.real))"
+
+lemma DEF_sum: "(op =::(('q_67488::type => bool)
+        => ('q_67488::type => hollight.real) => hollight.real)
+       => (('q_67488::type => bool)
+           => ('q_67488::type => hollight.real) => hollight.real)
+          => bool)
+ (hollight.sum::('q_67488::type => bool)
+                => ('q_67488::type => hollight.real) => hollight.real)
+ ((iterate::(hollight.real => hollight.real => hollight.real)
+            => ('q_67488::type => bool)
+               => ('q_67488::type => hollight.real) => hollight.real)
+   (real_add::hollight.real => hollight.real => hollight.real))"
+  by (import hollight DEF_sum)
+
+lemma NEUTRAL_REAL_ADD: "neutral real_add = real_of_num 0"
+  by (import hollight NEUTRAL_REAL_ADD)
+
+lemma NEUTRAL_REAL_MUL: "neutral real_mul = real_of_num 1"
+  by (import hollight NEUTRAL_REAL_MUL)
+
+lemma MONOIDAL_REAL_ADD: "monoidal real_add"
+  by (import hollight MONOIDAL_REAL_ADD)
+
+lemma MONOIDAL_REAL_MUL: "monoidal real_mul"
+  by (import hollight MONOIDAL_REAL_MUL)
+
+lemma SUM_CLAUSES: "(ALL x::'q_67530 => hollight.real.
+    hollight.sum {} x = real_of_num (0::nat)) &
+(ALL (x::'q_67571) (xa::'q_67571 => hollight.real) xb::'q_67571 => bool.
+    finite xb -->
+    hollight.sum (insert x xb) xa =
+    (if x : xb then hollight.sum xb xa
+     else real_add (xa x) (hollight.sum xb xa)))"
+  by (import hollight SUM_CLAUSES)
+
+lemma SUM_UNION: "finite (xa::'q_67597 => bool) &
+finite (xb::'q_67597 => bool) & xa Int xb = {}
+==> hollight.sum (xa Un xb) (x::'q_67597 => hollight.real) =
+    real_add (hollight.sum xa x) (hollight.sum xb x)"
+  by (import hollight SUM_UNION)
+
+lemma SUM_DIFF: "finite (xa::'q_67637 => bool) & (xb::'q_67637 => bool) <= xa
+==> hollight.sum (xa - xb) (x::'q_67637 => hollight.real) =
+    real_sub (hollight.sum xa x) (hollight.sum xb x)"
+  by (import hollight SUM_DIFF)
+
+lemma SUM_INCL_EXCL: "finite (x::'A => bool) & finite (xa::'A => bool)
+==> real_add (hollight.sum x (xb::'A => hollight.real))
+     (hollight.sum xa xb) =
+    real_add (hollight.sum (x Un xa) xb) (hollight.sum (x Int xa) xb)"
+  by (import hollight SUM_INCL_EXCL)
+
+lemma SUM_SUPPORT: "hollight.sum
+ (support real_add (x::'q_67726 => hollight.real) (xa::'q_67726 => bool))
+ x =
+hollight.sum xa x"
+  by (import hollight SUM_SUPPORT)
+
+lemma SUM_ADD: "finite (xb::'q_67760 => bool)
+==> hollight.sum xb
+     (%xb::'q_67760.
+         real_add ((x::'q_67760 => hollight.real) xb)
+          ((xa::'q_67760 => hollight.real) xb)) =
+    real_add (hollight.sum xb x) (hollight.sum xb xa)"
+  by (import hollight SUM_ADD)
+
+lemma SUM_ADD_GEN: "finite
+ {xa::'q_67851.
+  EX xc::'q_67851.
+     (xc : (xb::'q_67851 => bool) &
+      (x::'q_67851 => hollight.real) xc ~= real_of_num (0::nat)) &
+     xa = xc} &
+finite
+ {x::'q_67851.
+  EX xc::'q_67851.
+     (xc : xb &
+      (xa::'q_67851 => hollight.real) xc ~= real_of_num (0::nat)) &
+     x = xc}
+==> hollight.sum xb (%xb::'q_67851. real_add (x xb) (xa xb)) =
+    real_add (hollight.sum xb x) (hollight.sum xb xa)"
+  by (import hollight SUM_ADD_GEN)
+
+lemma SUM_EQ_0: "(!!xb::'A.
+    xb : (xa::'A => bool)
+    ==> (x::'A => hollight.real) xb = real_of_num (0::nat))
+==> hollight.sum xa x = real_of_num (0::nat)"
+  by (import hollight SUM_EQ_0)
+
+lemma SUM_0: "hollight.sum (x::'A => bool) (%n::'A. real_of_num (0::nat)) =
+real_of_num (0::nat)"
+  by (import hollight SUM_0)
+
+lemma SUM_LMUL: "hollight.sum (s::'A => bool)
+ (%x::'A. real_mul (c::hollight.real) ((f::'A => hollight.real) x)) =
+real_mul c (hollight.sum s f)"
+  by (import hollight SUM_LMUL)
+
+lemma SUM_RMUL: "hollight.sum (xb::'A => bool)
+ (%xb::'A. real_mul ((x::'A => hollight.real) xb) (xa::hollight.real)) =
+real_mul (hollight.sum xb x) xa"
+  by (import hollight SUM_RMUL)
+
+lemma SUM_NEG: "hollight.sum (xa::'q_68051 => bool)
+ (%xa::'q_68051. real_neg ((x::'q_68051 => hollight.real) xa)) =
+real_neg (hollight.sum xa x)"
+  by (import hollight SUM_NEG)
+
+lemma SUM_SUB: "finite (xb::'q_68086 => bool)
+==> hollight.sum xb
+     (%xb::'q_68086.
+         real_sub ((x::'q_68086 => hollight.real) xb)
+          ((xa::'q_68086 => hollight.real) xb)) =
+    real_sub (hollight.sum xb x) (hollight.sum xb xa)"
+  by (import hollight SUM_SUB)
+
+lemma SUM_LE: "finite (xb::'q_68128 => bool) &
+(ALL xc::'q_68128.
+    xc : xb -->
+    real_le ((x::'q_68128 => hollight.real) xc)
+     ((xa::'q_68128 => hollight.real) xc))
+==> real_le (hollight.sum xb x) (hollight.sum xb xa)"
+  by (import hollight SUM_LE)
+
+lemma SUM_LT: "finite (s::'A => bool) &
+(ALL x::'A.
+    x : s -->
+    real_le ((f::'A => hollight.real) x) ((g::'A => hollight.real) x)) &
+(EX x::'A. x : s & real_lt (f x) (g x))
+==> real_lt (hollight.sum s f) (hollight.sum s g)"
+  by (import hollight SUM_LT)
+
+lemma SUM_LT_ALL: "finite (s::'q_68250 => bool) &
+s ~= {} &
+(ALL x::'q_68250.
+    x : s -->
+    real_lt ((f::'q_68250 => hollight.real) x)
+     ((g::'q_68250 => hollight.real) x))
+==> real_lt (hollight.sum s f) (hollight.sum s g)"
+  by (import hollight SUM_LT_ALL)
+
+lemma SUM_EQ: "(!!xc::'q_68288.
+    xc : (xb::'q_68288 => bool)
+    ==> (x::'q_68288 => hollight.real) xc =
+        (xa::'q_68288 => hollight.real) xc)
+==> hollight.sum xb x = hollight.sum xb xa"
+  by (import hollight SUM_EQ)
+
+lemma SUM_ABS: "finite (s::'q_68347 => bool)
+==> real_le (real_abs (hollight.sum s (f::'q_68347 => hollight.real)))
+     (hollight.sum s (%x::'q_68347. real_abs (f x)))"
+  by (import hollight SUM_ABS)
+
+lemma SUM_ABS_LE: "finite (s::'A => bool) &
+(ALL x::'A.
+    x : s -->
+    real_le (real_abs ((f::'A => hollight.real) x))
+     ((g::'A => hollight.real) x))
+==> real_le (real_abs (hollight.sum s f)) (hollight.sum s g)"
+  by (import hollight SUM_ABS_LE)
+
+lemma SUM_CONST: "finite (s::'q_68423 => bool)
+==> hollight.sum s (%n::'q_68423. c::hollight.real) =
+    real_mul (real_of_num (CARD s)) c"
+  by (import hollight SUM_CONST)
+
+lemma SUM_POS_LE: "finite (xa::'q_68465 => bool) &
+(ALL xb::'q_68465.
+    xb : xa -->
+    real_le (real_of_num (0::nat)) ((x::'q_68465 => hollight.real) xb))
+==> real_le (real_of_num (0::nat)) (hollight.sum xa x)"
+  by (import hollight SUM_POS_LE)
+
+lemma SUM_POS_BOUND: "[| finite (x::'A => bool) &
+   (ALL xa::'A.
+       xa : x -->
+       real_le (real_of_num (0::nat)) ((f::'A => hollight.real) xa)) &
+   real_le (hollight.sum x f) (b::hollight.real);
+   (xa::'A) : x |]
+==> real_le (f xa) b"
+  by (import hollight SUM_POS_BOUND)
+
+lemma SUM_POS_EQ_0: "[| finite (xa::'q_68612 => bool) &
+   (ALL xb::'q_68612.
+       xb : xa -->
+       real_le (real_of_num (0::nat)) ((x::'q_68612 => hollight.real) xb)) &
+   hollight.sum xa x = real_of_num (0::nat);
+   (xb::'q_68612) : xa |]
+==> x xb = real_of_num (0::nat)"
+  by (import hollight SUM_POS_EQ_0)
+
+lemma SUM_ZERO_EXISTS: "finite (s::'A => bool) &
+hollight.sum s (u::'A => hollight.real) = real_of_num (0::nat)
+==> (ALL i::'A. i : s --> u i = real_of_num (0::nat)) |
+    (EX (j::'A) k::'A.
+        j : s &
+        real_lt (u j) (real_of_num (0::nat)) &
+        k : s & real_gt (u k) (real_of_num (0::nat)))"
+  by (import hollight SUM_ZERO_EXISTS)
+
+lemma SUM_DELETE: "finite (xa::'q_68854 => bool) & (xb::'q_68854) : xa
+==> hollight.sum (xa - {xb}) (x::'q_68854 => hollight.real) =
+    real_sub (hollight.sum xa x) (x xb)"
+  by (import hollight SUM_DELETE)
+
+lemma SUM_DELETE_CASES: "finite (s::'q_68907 => bool)
+==> hollight.sum (s - {a::'q_68907}) (f::'q_68907 => hollight.real) =
+    (if a : s then real_sub (hollight.sum s f) (f a) else hollight.sum s f)"
+  by (import hollight SUM_DELETE_CASES)
+
+lemma SUM_SING: "hollight.sum {xa::'q_68930} (x::'q_68930 => hollight.real) = x xa"
+  by (import hollight SUM_SING)
+
+lemma SUM_DELTA: "hollight.sum (x::'A => bool)
+ (%x::'A. if x = (xa::'A) then b::hollight.real else real_of_num (0::nat)) =
+(if xa : x then b else real_of_num (0::nat))"
+  by (import hollight SUM_DELTA)
+
+lemma SUM_SWAP: "finite (x::'A => bool) & finite (xa::'B => bool)
+==> hollight.sum x
+     (%i::'A. hollight.sum xa ((f::'A => 'B => hollight.real) i)) =
+    hollight.sum xa (%j::'B. hollight.sum x (%i::'A. f i j))"
+  by (import hollight SUM_SWAP)
+
+lemma SUM_IMAGE: "(!!(xa::'q_69070) y::'q_69070.
+    xa : (xb::'q_69070 => bool) &
+    y : xb & (x::'q_69070 => 'q_69046) xa = x y
+    ==> xa = y)
+==> hollight.sum (x ` xb) (xa::'q_69046 => hollight.real) =
+    hollight.sum xb (xa o x)"
+  by (import hollight SUM_IMAGE)
+
+lemma SUM_SUPERSET: "(xa::'A => bool) <= (xb::'A => bool) &
+(ALL xc::'A.
+    xc : xb & xc ~: xa -->
+    (x::'A => hollight.real) xc = real_of_num (0::nat))
+==> hollight.sum xb x = hollight.sum xa x"
+  by (import hollight SUM_SUPERSET)
+
+lemma SUM_UNION_RZERO: "finite (u::'A => bool) &
+(ALL x::'A.
+    x : (v::'A => bool) & x ~: u -->
+    (f::'A => hollight.real) x = real_of_num (0::nat))
+==> hollight.sum (u Un v) f = hollight.sum u f"
+  by (import hollight SUM_UNION_RZERO)
+
+lemma SUM_UNION_LZERO: "finite (v::'A => bool) &
+(ALL x::'A.
+    x : (u::'A => bool) & x ~: v -->
+    (f::'A => hollight.real) x = real_of_num (0::nat))
+==> hollight.sum (u Un v) f = hollight.sum v f"
+  by (import hollight SUM_UNION_LZERO)
+
+lemma SUM_RESTRICT: "finite (s::'q_69267 => bool)
+==> hollight.sum s
+     (%x::'q_69267.
+         if x : s then (f::'q_69267 => hollight.real) x
+         else real_of_num (0::nat)) =
+    hollight.sum s f"
+  by (import hollight SUM_RESTRICT)
+
+lemma SUM_BOUND: "finite (x::'A => bool) &
+(ALL xc::'A.
+    xc : x --> real_le ((xa::'A => hollight.real) xc) (xb::hollight.real))
+==> real_le (hollight.sum x xa) (real_mul (real_of_num (CARD x)) xb)"
+  by (import hollight SUM_BOUND)
+
+lemma SUM_BOUND_GEN: "finite (s::'A => bool) &
+s ~= {} &
+(ALL x::'A.
+    x : s -->
+    real_le ((f::'A => hollight.real) x)
+     (real_div (b::hollight.real) (real_of_num (CARD s))))
+==> real_le (hollight.sum s f) b"
+  by (import hollight SUM_BOUND_GEN)
+
+lemma SUM_ABS_BOUND: "finite (s::'A => bool) &
+(ALL x::'A.
+    x : s -->
+    real_le (real_abs ((f::'A => hollight.real) x)) (b::hollight.real))
+==> real_le (real_abs (hollight.sum s f))
+     (real_mul (real_of_num (CARD s)) b)"
+  by (import hollight SUM_ABS_BOUND)
+
+lemma SUM_BOUND_LT: "finite (s::'A => bool) &
+(ALL x::'A.
+    x : s --> real_le ((f::'A => hollight.real) x) (b::hollight.real)) &
+(EX x::'A. x : s & real_lt (f x) b)
+==> real_lt (hollight.sum s f) (real_mul (real_of_num (CARD s)) b)"
+  by (import hollight SUM_BOUND_LT)
+
+lemma SUM_BOUND_LT_ALL: "finite (s::'q_69531 => bool) &
+s ~= {} &
+(ALL x::'q_69531.
+    x : s --> real_lt ((f::'q_69531 => hollight.real) x) (b::hollight.real))
+==> real_lt (hollight.sum s f) (real_mul (real_of_num (CARD s)) b)"
+  by (import hollight SUM_BOUND_LT_ALL)
+
+lemma SUM_BOUND_LT_GEN: "finite (s::'A => bool) &
+s ~= {} &
+(ALL x::'A.
+    x : s -->
+    real_lt ((f::'A => hollight.real) x)
+     (real_div (b::hollight.real) (real_of_num (CARD s))))
+==> real_lt (hollight.sum s f) b"
+  by (import hollight SUM_BOUND_LT_GEN)
+
+lemma SUM_UNION_EQ: "finite (u::'q_69614 => bool) &
+(s::'q_69614 => bool) Int (t::'q_69614 => bool) = {} & s Un t = u
+==> real_add (hollight.sum s (f::'q_69614 => hollight.real))
+     (hollight.sum t f) =
+    hollight.sum u f"
+  by (import hollight SUM_UNION_EQ)
+
+lemma SUM_EQ_SUPERSET: "finite (t::'A => bool) &
+t <= (s::'A => bool) &
+(ALL x::'A.
+    x : t --> (f::'A => hollight.real) x = (g::'A => hollight.real) x) &
+(ALL x::'A. x : s & x ~: t --> f x = real_of_num (0::nat))
+==> hollight.sum s f = hollight.sum t g"
+  by (import hollight SUM_EQ_SUPERSET)
+
+lemma SUM_RESTRICT_SET: "hollight.sum
+ {u::'q_69783.
+  EX xb::'q_69783.
+     (xb : (xa::'q_69783 => bool) & (x::'q_69783 => bool) xb) & u = xb}
+ (xb::'q_69783 => hollight.real) =
+hollight.sum xa
+ (%xa::'q_69783. if x xa then xb xa else real_of_num (0::nat))"
+  by (import hollight SUM_RESTRICT_SET)
+
+lemma SUM_SUM_RESTRICT: "finite (s::'q_69875 => bool) & finite (t::'q_69874 => bool)
+==> hollight.sum s
+     (%x::'q_69875.
+         hollight.sum
+          {u::'q_69874.
+           EX y::'q_69874.
+              (y : t & (R::'q_69875 => 'q_69874 => bool) x y) & u = y}
+          ((f::'q_69875 => 'q_69874 => hollight.real) x)) =
+    hollight.sum t
+     (%y::'q_69874.
+         hollight.sum {u::'q_69875. EX x::'q_69875. (x : s & R x y) & u = x}
+          (%x::'q_69875. f x y))"
+  by (import hollight SUM_SUM_RESTRICT)
+
+lemma CARD_EQ_SUM: "finite (x::'q_69896 => bool)
+==> real_of_num (CARD x) =
+    hollight.sum x (%x::'q_69896. real_of_num (1::nat))"
+  by (import hollight CARD_EQ_SUM)
+
+lemma SUM_MULTICOUNT_GEN: "finite (s::'A => bool) &
+finite (t::'B => bool) &
+(ALL j::'B.
+    j : t -->
+    CARD {u::'A. EX i::'A. (i : s & (R::'A => 'B => bool) i j) & u = i} =
+    (k::'B => nat) j)
+==> hollight.sum s
+     (%i::'A.
+         real_of_num (CARD {u::'B. EX j::'B. (j : t & R i j) & u = j})) =
+    hollight.sum t (%i::'B. real_of_num (k i))"
+  by (import hollight SUM_MULTICOUNT_GEN)
+
+lemma SUM_MULTICOUNT: "finite (s::'A => bool) &
+finite (t::'B => bool) &
+(ALL j::'B.
+    j : t -->
+    CARD {u::'A. EX i::'A. (i : s & (R::'A => 'B => bool) i j) & u = i} =
+    (k::nat))
+==> hollight.sum s
+     (%i::'A.
+         real_of_num (CARD {u::'B. EX j::'B. (j : t & R i j) & u = j})) =
+    real_of_num (k * CARD t)"
+  by (import hollight SUM_MULTICOUNT)
+
+lemma SUM_IMAGE_GEN: "finite (s::'A => bool)
+==> hollight.sum s (g::'A => hollight.real) =
+    hollight.sum ((f::'A => 'B) ` s)
+     (%y::'B. hollight.sum {u::'A. EX x::'A. (x : s & f x = y) & u = x} g)"
+  by (import hollight SUM_IMAGE_GEN)
+
+lemma SUM_GROUP: "finite (s::'A => bool) & (f::'A => 'B) ` s <= (t::'B => bool)
+==> hollight.sum t
+     (%y::'B.
+         hollight.sum {u::'A. EX x::'A. (x : s & f x = y) & u = x}
+          (g::'A => hollight.real)) =
+    hollight.sum s g"
+  by (import hollight SUM_GROUP)
+
+lemma REAL_OF_NUM_SUM: "finite (s::'q_70361 => bool)
+==> real_of_num (nsum s (f::'q_70361 => nat)) =
+    hollight.sum s (%x::'q_70361. real_of_num (f x))"
+  by (import hollight REAL_OF_NUM_SUM)
+
+lemma SUM_SUBSET: "finite (u::'A => bool) &
+finite (v::'A => bool) &
+(ALL x::'A.
+    x : u - v -->
+    real_le ((f::'A => hollight.real) x) (real_of_num (0::nat))) &
+(ALL x::'A. x : v - u --> real_le (real_of_num (0::nat)) (f x))
+==> real_le (hollight.sum u f) (hollight.sum v f)"
+  by (import hollight SUM_SUBSET)
+
+lemma SUM_SUBSET_SIMPLE: "finite (v::'A => bool) &
+(u::'A => bool) <= v &
+(ALL x::'A.
+    x : v - u -->
+    real_le (real_of_num (0::nat)) ((f::'A => hollight.real) x))
+==> real_le (hollight.sum u f) (hollight.sum v f)"
+  by (import hollight SUM_SUBSET_SIMPLE)
+
+lemma SUM_IMAGE_NONZERO: "finite (xb::'A => bool) &
+(ALL (xc::'A) xd::'A.
+    xc : xb & xd : xb & xc ~= xd & (xa::'A => 'B) xc = xa xd -->
+    (x::'B => hollight.real) (xa xc) = real_of_num (0::nat))
+==> hollight.sum (xa ` xb) x = hollight.sum xb (x o xa)"
+  by (import hollight SUM_IMAGE_NONZERO)
+
+lemma SUM_BIJECTION: "(ALL x::'A. x : (xb::'A => bool) --> (xa::'A => 'A) x : xb) &
+(ALL y::'A. y : xb --> (EX! x::'A. x : xb & xa x = y))
+==> hollight.sum xb (x::'A => hollight.real) = hollight.sum xb (x o xa)"
+  by (import hollight SUM_BIJECTION)
+
+lemma SUM_SUM_PRODUCT: "finite (x::'A => bool) &
+(ALL i::'A. i : x --> finite ((xa::'A => 'B => bool) i))
+==> hollight.sum x
+     (%x::'A. hollight.sum (xa x) ((xb::'A => 'B => hollight.real) x)) =
+    hollight.sum
+     {u::'A * 'B. EX (i::'A) j::'B. (i : x & j : xa i) & u = (i, j)}
+     (SOME f::'A * 'B => hollight.real.
+         ALL (i::'A) j::'B. f (i, j) = xb i j)"
+  by (import hollight SUM_SUM_PRODUCT)
+
+lemma SUM_EQ_GENERAL: "(ALL y::'B.
+    y : (xa::'B => bool) -->
+    (EX! xa::'A. xa : (x::'A => bool) & (xd::'A => 'B) xa = y)) &
+(ALL xe::'A.
+    xe : x -->
+    xd xe : xa &
+    (xc::'B => hollight.real) (xd xe) = (xb::'A => hollight.real) xe)
+==> hollight.sum x xb = hollight.sum xa xc"
+  by (import hollight SUM_EQ_GENERAL)
+
+lemma SUM_EQ_GENERAL_INVERSES: "(ALL y::'B.
+    y : (xa::'B => bool) -->
+    (xe::'B => 'A) y : (x::'A => bool) & (xd::'A => 'B) (xe y) = y) &
+(ALL xf::'A.
+    xf : x -->
+    xd xf : xa &
+    xe (xd xf) = xf &
+    (xc::'B => hollight.real) (xd xf) = (xb::'A => hollight.real) xf)
+==> hollight.sum x xb = hollight.sum xa xc"
+  by (import hollight SUM_EQ_GENERAL_INVERSES)
+
+lemma SUM_INJECTION: "finite (xb::'q_71007 => bool) &
+(ALL x::'q_71007. x : xb --> (xa::'q_71007 => 'q_71007) x : xb) &
+(ALL (x::'q_71007) y::'q_71007. x : xb & y : xb & xa x = xa y --> x = y)
+==> hollight.sum xb ((x::'q_71007 => hollight.real) o xa) =
+    hollight.sum xb x"
+  by (import hollight SUM_INJECTION)
+
+lemma SUM_UNION_NONZERO: "finite (xa::'q_71050 => bool) &
+finite (xb::'q_71050 => bool) &
+(ALL xc::'q_71050.
+    xc : xa Int xb -->
+    (x::'q_71050 => hollight.real) xc = real_of_num (0::nat))
+==> hollight.sum (xa Un xb) x =
+    real_add (hollight.sum xa x) (hollight.sum xb x)"
+  by (import hollight SUM_UNION_NONZERO)
+
+lemma SUM_UNIONS_NONZERO: "finite (x::('A => bool) => bool) &
+(ALL t::'A => bool. t : x --> finite t) &
+(ALL (t1::'A => bool) (t2::'A => bool) xa::'A.
+    t1 : x & t2 : x & t1 ~= t2 & xa : t1 & xa : t2 -->
+    (f::'A => hollight.real) xa = real_of_num (0::nat))
+==> hollight.sum (Union x) f =
+    hollight.sum x (%t::'A => bool. hollight.sum t f)"
+  by (import hollight SUM_UNIONS_NONZERO)
+
+lemma SUM_CASES: "finite (x::'A => bool)
+==> hollight.sum x
+     (%x::'A.
+         if (xa::'A => bool) x then (xb::'A => hollight.real) x
+         else (xc::'A => hollight.real) x) =
+    real_add (hollight.sum {u::'A. EX xb::'A. (xb : x & xa xb) & u = xb} xb)
+     (hollight.sum {u::'A. EX xb::'A. (xb : x & ~ xa xb) & u = xb} xc)"
+  by (import hollight SUM_CASES)
+
+lemma SUM_CASES_1: "finite (s::'q_71319 => bool) & (a::'q_71319) : s
+==> hollight.sum s
+     (%x::'q_71319.
+         if x = a then y::hollight.real
+         else (f::'q_71319 => hollight.real) x) =
+    real_add (hollight.sum s f) (real_sub y (f a))"
+  by (import hollight SUM_CASES_1)
+
+lemma SUM_LE_INCLUDED: "finite (s::'A => bool) &
+finite (t::'B => bool) &
+(ALL y::'B.
+    y : t --> real_le (real_of_num (0::nat)) ((g::'B => hollight.real) y)) &
+(ALL x::'A.
+    x : s -->
+    (EX y::'B.
+        y : t &
+        (i::'B => 'A) y = x & real_le ((f::'A => hollight.real) x) (g y)))
+==> real_le (hollight.sum s f) (hollight.sum t g)"
+  by (import hollight SUM_LE_INCLUDED)
+
+lemma SUM_IMAGE_LE: "finite (s::'A => bool) &
+(ALL x::'A.
+    x : s -->
+    real_le (real_of_num (0::nat))
+     ((g::'B => hollight.real) ((f::'A => 'B) x)))
+==> real_le (hollight.sum (f ` s) g) (hollight.sum s (g o f))"
+  by (import hollight SUM_IMAGE_LE)
+
+lemma SUM_CLOSED: "(P::hollight.real => bool) (real_of_num (0::nat)) &
+(ALL (x::hollight.real) y::hollight.real. P x & P y --> P (real_add x y)) &
+(ALL a::'A. a : (s::'A => bool) --> P ((f::'A => hollight.real) a))
+==> P (hollight.sum s f)"
+  by (import hollight SUM_CLOSED)
+
+lemma SUM_ADD_NUMSEG: "hollight.sum {xb::nat..xc::nat}
+ (%i::nat.
+     real_add ((x::nat => hollight.real) i)
+      ((xa::nat => hollight.real) i)) =
+real_add (hollight.sum {xb..xc} x) (hollight.sum {xb..xc} xa)"
+  by (import hollight SUM_ADD_NUMSEG)
+
+lemma SUM_SUB_NUMSEG: "hollight.sum {xb::nat..xc::nat}
+ (%i::nat.
+     real_sub ((x::nat => hollight.real) i)
+      ((xa::nat => hollight.real) i)) =
+real_sub (hollight.sum {xb..xc} x) (hollight.sum {xb..xc} xa)"
+  by (import hollight SUM_SUB_NUMSEG)
+
+lemma SUM_LE_NUMSEG: "(!!i::nat.
+    (xb::nat) <= i & i <= (xc::nat)
+    ==> real_le ((x::nat => hollight.real) i)
+         ((xa::nat => hollight.real) i))
+==> real_le (hollight.sum {xb..xc} x) (hollight.sum {xb..xc} xa)"
+  by (import hollight SUM_LE_NUMSEG)
+
+lemma SUM_EQ_NUMSEG: "(!!i::nat.
+    (m::nat) <= i & i <= (n::nat)
+    ==> (f::nat => hollight.real) i = (g::nat => hollight.real) i)
+==> hollight.sum {m..n} f = hollight.sum {m..n} g"
+  by (import hollight SUM_EQ_NUMSEG)
+
+lemma SUM_ABS_NUMSEG: "real_le
+ (real_abs (hollight.sum {xa::nat..xb::nat} (x::nat => hollight.real)))
+ (hollight.sum {xa..xb} (%i::nat. real_abs (x i)))"
+  by (import hollight SUM_ABS_NUMSEG)
+
+lemma SUM_CONST_NUMSEG: "hollight.sum {xa..xb} (%n. x) = real_mul (real_of_num (xb + 1 - xa)) x"
+  by (import hollight SUM_CONST_NUMSEG)
+
+lemma SUM_EQ_0_NUMSEG: "(!!i::nat.
+    (m::nat) <= i & i <= (n::nat)
+    ==> (x::nat => hollight.real) i = real_of_num (0::nat))
+==> hollight.sum {m..n} x = real_of_num (0::nat)"
+  by (import hollight SUM_EQ_0_NUMSEG)
+
+lemma SUM_TRIV_NUMSEG: "(n::nat) < (m::nat)
+==> hollight.sum {m..n} (f::nat => hollight.real) = real_of_num (0::nat)"
+  by (import hollight SUM_TRIV_NUMSEG)
+
+lemma SUM_POS_LE_NUMSEG: "(!!p::nat.
+    (x::nat) <= p & p <= (xa::nat)
+    ==> real_le (real_of_num (0::nat)) ((xb::nat => hollight.real) p))
+==> real_le (real_of_num (0::nat)) (hollight.sum {x..xa} xb)"
+  by (import hollight SUM_POS_LE_NUMSEG)
+
+lemma SUM_POS_EQ_0_NUMSEG: "[| (ALL p::nat.
+       (m::nat) <= p & p <= (n::nat) -->
+       real_le (real_of_num (0::nat)) ((f::nat => hollight.real) p)) &
+   hollight.sum {m..n} f = real_of_num (0::nat);
+   m <= (p::nat) & p <= n |]
+==> f p = real_of_num (0::nat)"
+  by (import hollight SUM_POS_EQ_0_NUMSEG)
+
+lemma SUM_SING_NUMSEG: "hollight.sum {xa::nat..xa} (x::nat => hollight.real) = x xa"
+  by (import hollight SUM_SING_NUMSEG)
+
+lemma SUM_CLAUSES_NUMSEG: "(ALL m. hollight.sum {m..0} f = (if m = 0 then f 0 else real_of_num 0)) &
+(ALL m n.
+    hollight.sum {m..Suc n} f =
+    (if m <= Suc n then real_add (hollight.sum {m..n} f) (f (Suc n))
+     else hollight.sum {m..n} f))"
+  by (import hollight SUM_CLAUSES_NUMSEG)
+
+lemma SUM_SWAP_NUMSEG: "hollight.sum {a::nat..b::nat}
+ (%i::nat.
+     hollight.sum {c::nat..d::nat} ((f::nat => nat => hollight.real) i)) =
+hollight.sum {c..d} (%j::nat. hollight.sum {a..b} (%i::nat. f i j))"
+  by (import hollight SUM_SWAP_NUMSEG)
+
+lemma SUM_ADD_SPLIT: "(xa::nat) <= (xb::nat) + (1::nat)
+==> hollight.sum {xa..xb + (xc::nat)} (x::nat => hollight.real) =
+    real_add (hollight.sum {xa..xb} x)
+     (hollight.sum {xb + (1::nat)..xb + xc} x)"
+  by (import hollight SUM_ADD_SPLIT)
+
+lemma SUM_OFFSET: "hollight.sum {(xb::nat) + (x::nat)..(xc::nat) + x}
+ (xa::nat => hollight.real) =
+hollight.sum {xb..xc} (%i::nat. xa (i + x))"
+  by (import hollight SUM_OFFSET)
+
+lemma SUM_OFFSET_0: "(xa::nat) <= (xb::nat)
+==> hollight.sum {xa..xb} (x::nat => hollight.real) =
+    hollight.sum {0::nat..xb - xa} (%i::nat. x (i + xa))"
+  by (import hollight SUM_OFFSET_0)
+
+lemma SUM_CLAUSES_LEFT: "(xa::nat) <= (xb::nat)
+==> hollight.sum {xa..xb} (x::nat => hollight.real) =
+    real_add (x xa) (hollight.sum {xa + (1::nat)..xb} x)"
+  by (import hollight SUM_CLAUSES_LEFT)
+
+lemma SUM_CLAUSES_RIGHT: "(0::nat) < (n::nat) & (m::nat) <= n
+==> hollight.sum {m..n} (f::nat => hollight.real) =
+    real_add (hollight.sum {m..n - (1::nat)} f) (f n)"
+  by (import hollight SUM_CLAUSES_RIGHT)
+
+lemma SUM_PAIR: "hollight.sum {(2::nat) * (m::nat)..(2::nat) * (n::nat) + (1::nat)}
+ (f::nat => hollight.real) =
+hollight.sum {m..n}
+ (%i::nat. real_add (f ((2::nat) * i)) (f ((2::nat) * i + (1::nat))))"
+  by (import hollight SUM_PAIR)
+
+lemma REAL_OF_NUM_SUM_NUMSEG: "real_of_num (nsum {xa::nat..xb::nat} (x::nat => nat)) =
+hollight.sum {xa..xb} (%i::nat. real_of_num (x i))"
+  by (import hollight REAL_OF_NUM_SUM_NUMSEG)
+
+lemma SUM_PARTIAL_SUC: "hollight.sum {m::nat..n::nat}
+ (%k::nat.
+     real_mul ((f::nat => hollight.real) k)
+      (real_sub ((g::nat => hollight.real) (k + (1::nat))) (g k))) =
+(if m <= n
+ then real_sub
+       (real_sub (real_mul (f (n + (1::nat))) (g (n + (1::nat))))
+         (real_mul (f m) (g m)))
+       (hollight.sum {m..n}
+         (%k::nat.
+             real_mul (g (k + (1::nat)))
+              (real_sub (f (k + (1::nat))) (f k))))
+ else real_of_num (0::nat))"
+  by (import hollight SUM_PARTIAL_SUC)
+
+lemma SUM_PARTIAL_PRE: "hollight.sum {m::nat..n::nat}
+ (%k::nat.
+     real_mul ((f::nat => hollight.real) k)
+      (real_sub ((g::nat => hollight.real) k) (g (k - (1::nat))))) =
+(if m <= n
+ then real_sub
+       (real_sub (real_mul (f (n + (1::nat))) (g n))
+         (real_mul (f m) (g (m - (1::nat)))))
+       (hollight.sum {m..n}
+         (%k::nat. real_mul (g k) (real_sub (f (k + (1::nat))) (f k))))
+ else real_of_num (0::nat))"
+  by (import hollight SUM_PARTIAL_PRE)
+
+lemma SUM_DIFFS: "hollight.sum {x::nat..xa::nat}
+ (%x::nat. real_sub ((f::nat => hollight.real) x) (f (x + (1::nat)))) =
+(if x <= xa then real_sub (f x) (f (xa + (1::nat)))
+ else real_of_num (0::nat))"
+  by (import hollight SUM_DIFFS)
+
+lemma SUM_DIFFS_ALT: "hollight.sum {m::nat..n::nat}
+ (%x::nat. real_sub ((f::nat => hollight.real) (x + (1::nat))) (f x)) =
+(if m <= n then real_sub (f (n + (1::nat))) (f m) else real_of_num (0::nat))"
+  by (import hollight SUM_DIFFS_ALT)
+
+lemma SUM_COMBINE_R: "(m::nat) <= (n::nat) + (1::nat) & n <= (p::nat)
+==> real_add (hollight.sum {m..n} (f::nat => hollight.real))
+     (hollight.sum {n + (1::nat)..p} f) =
+    hollight.sum {m..p} f"
+  by (import hollight SUM_COMBINE_R)
+
+lemma SUM_COMBINE_L: "(0::nat) < (n::nat) & (m::nat) <= n & n <= (p::nat) + (1::nat)
+==> real_add (hollight.sum {m..n - (1::nat)} (f::nat => hollight.real))
+     (hollight.sum {n..p} f) =
+    hollight.sum {m..p} f"
+  by (import hollight SUM_COMBINE_L)
+
+lemma REAL_SUB_POW: "1 <= xb
+==> real_sub (real_pow x xb) (real_pow xa xb) =
+    real_mul (real_sub x xa)
+     (hollight.sum {0..xb - 1}
+       (%i. real_mul (real_pow x i) (real_pow xa (xb - 1 - i))))"
+  by (import hollight REAL_SUB_POW)
+
+lemma REAL_SUB_POW_R1: "1 <= n
+==> real_sub (real_pow x n) (real_of_num 1) =
+    real_mul (real_sub x (real_of_num 1))
+     (hollight.sum {0..n - 1} (real_pow x))"
+  by (import hollight REAL_SUB_POW_R1)
+
+lemma REAL_SUB_POW_L1: "1 <= xa
+==> real_sub (real_of_num 1) (real_pow x xa) =
+    real_mul (real_sub (real_of_num 1) x)
+     (hollight.sum {0..xa - 1} (real_pow x))"
+  by (import hollight REAL_SUB_POW_L1)
+
+definition
+  dimindex :: "('A => bool) => nat"  where
+  "(op ==::(('A::type => bool) => nat) => (('A::type => bool) => nat) => prop)
+ (dimindex::('A::type => bool) => nat)
+ (%u::'A::type => bool.
+     (If::bool => nat => nat => nat)
+      ((finite::('A::type => bool) => bool) (UNIV::'A::type => bool))
+      ((CARD::('A::type => bool) => nat) (UNIV::'A::type => bool)) (1::nat))"
+
+lemma DEF_dimindex: "(op =::(('A::type => bool) => nat) => (('A::type => bool) => nat) => bool)
+ (dimindex::('A::type => bool) => nat)
+ (%u::'A::type => bool.
+     (If::bool => nat => nat => nat)
+      ((finite::('A::type => bool) => bool) (UNIV::'A::type => bool))
+      ((CARD::('A::type => bool) => nat) (UNIV::'A::type => bool)) (1::nat))"
+  by (import hollight DEF_dimindex)
+
+lemma DIMINDEX_NONZERO: "dimindex (s::'A => bool) ~= (0::nat)"
+  by (import hollight DIMINDEX_NONZERO)
+
+lemma DIMINDEX_GE_1: "(1::nat) <= dimindex (x::'A => bool)"
+  by (import hollight DIMINDEX_GE_1)
+
+lemma DIMINDEX_UNIV: "(op =::nat => nat => bool)
+ ((dimindex::('A::type => bool) => nat) (x::'A::type => bool))
+ ((dimindex::('A::type => bool) => nat) (UNIV::'A::type => bool))"
+  by (import hollight DIMINDEX_UNIV)
+
+lemma DIMINDEX_UNIQUE: "(op ==>::prop => prop => prop)
+ ((Trueprop::bool => prop)
+   ((HAS_SIZE::('A::type => bool) => nat => bool) (UNIV::'A::type => bool)
+     (n::nat)))
+ ((Trueprop::bool => prop)
+   ((op =::nat => nat => bool)
+     ((dimindex::('A::type => bool) => nat) (UNIV::'A::type => bool)) n))"
+  by (import hollight DIMINDEX_UNIQUE)
+
+typedef (open) ('A) finite_image = "{x::nat. x : dotdot (NUMERAL (NUMERAL_BIT1 (0::nat))) (dimindex UNIV)}"  morphisms "dest_finite_image" "finite_index"
+  apply (rule light_ex_imp_nonempty[where t="SOME x::nat. x : dotdot (NUMERAL (NUMERAL_BIT1 (0::nat))) (dimindex UNIV)"])
+  by (import hollight TYDEF_finite_image)
+
+syntax
+  dest_finite_image :: _ 
+
+syntax
+  finite_index :: _ 
+
+lemmas "TYDEF_finite_image_@intern" = typedef_hol2hollight 
+  [where a="a :: 'A finite_image" and r=r ,
+   OF type_definition_finite_image]
+
+lemma FINITE_IMAGE_IMAGE: "(op =::('A::type finite_image => bool)
+       => ('A::type finite_image => bool) => bool)
+ (UNIV::'A::type finite_image => bool)
+ ((op `::(nat => 'A::type finite_image)
+         => (nat => bool) => 'A::type finite_image => bool)
+   (finite_index::nat => 'A::type finite_image)
+   ((atLeastAtMost::nat => nat => nat => bool) (1::nat)
+     ((dimindex::('A::type => bool) => nat) (UNIV::'A::type => bool))))"
+  by (import hollight FINITE_IMAGE_IMAGE)
+
+lemma HAS_SIZE_FINITE_IMAGE: "(HAS_SIZE::('A::type finite_image => bool) => nat => bool)
+ (UNIV::'A::type finite_image => bool)
+ ((dimindex::('A::type => bool) => nat) (s::'A::type => bool))"
+  by (import hollight HAS_SIZE_FINITE_IMAGE)
+
+lemma CARD_FINITE_IMAGE: "(op =::nat => nat => bool)
+ ((CARD::('A::type finite_image => bool) => nat)
+   (UNIV::'A::type finite_image => bool))
+ ((dimindex::('A::type => bool) => nat) (s::'A::type => bool))"
+  by (import hollight CARD_FINITE_IMAGE)
+
+lemma FINITE_FINITE_IMAGE: "(finite::('A::type finite_image => bool) => bool)
+ (UNIV::'A::type finite_image => bool)"
+  by (import hollight FINITE_FINITE_IMAGE)
+
+lemma DIMINDEX_FINITE_IMAGE: "dimindex (s::'A finite_image => bool) = dimindex (t::'A => bool)"
+  by (import hollight DIMINDEX_FINITE_IMAGE)
+
+lemma FINITE_INDEX_WORKS: "(Ex1::(nat => bool) => bool)
+ (%xa::nat.
+     (op &::bool => bool => bool) ((op <=::nat => nat => bool) (1::nat) xa)
+      ((op &::bool => bool => bool)
+        ((op <=::nat => nat => bool) xa
+          ((dimindex::('A::type => bool) => nat) (UNIV::'A::type => bool)))
+        ((op =::'A::type finite_image => 'A::type finite_image => bool)
+          ((finite_index::nat => 'A::type finite_image) xa)
+          (x::'A::type finite_image))))"
+  by (import hollight FINITE_INDEX_WORKS)
+
+lemma FINITE_INDEX_INJ: "(op ==>::prop => prop => prop)
+ ((Trueprop::bool => prop)
+   ((op &::bool => bool => bool)
+     ((op <=::nat => nat => bool) (1::nat) (i::nat))
+     ((op &::bool => bool => bool)
+       ((op <=::nat => nat => bool) i
+         ((dimindex::('A::type => bool) => nat) (UNIV::'A::type => bool)))
+       ((op &::bool => bool => bool)
+         ((op <=::nat => nat => bool) (1::nat) (j::nat))
+         ((op <=::nat => nat => bool) j
+           ((dimindex::('A::type => bool) => nat)
+             (UNIV::'A::type => bool)))))))
+ ((Trueprop::bool => prop)
+   ((op =::bool => bool => bool)
+     ((op =::'A::type finite_image => 'A::type finite_image => bool)
+       ((finite_index::nat => 'A::type finite_image) i)
+       ((finite_index::nat => 'A::type finite_image) j))
+     ((op =::nat => nat => bool) i j)))"
+  by (import hollight FINITE_INDEX_INJ)
+
+lemma FORALL_FINITE_INDEX: "(op =::bool => bool => bool)
+ ((All::('N::type finite_image => bool) => bool)
+   (P::'N::type finite_image => bool))
+ ((All::(nat => bool) => bool)
+   (%i::nat.
+       (op -->::bool => bool => bool)
+        ((op &::bool => bool => bool)
+          ((op <=::nat => nat => bool) (1::nat) i)
+          ((op <=::nat => nat => bool) i
+            ((dimindex::('N::type => bool) => nat)
+              (UNIV::'N::type => bool))))
+        (P ((finite_index::nat => 'N::type finite_image) i))))"
+  by (import hollight FORALL_FINITE_INDEX)
+
+typedef (open) ('A, 'B) cart = "{f. True}"  morphisms "dest_cart" "mk_cart"
+  apply (rule light_ex_imp_nonempty[where t="SOME f. True"])
+  by (import hollight TYDEF_cart)
+
+syntax
+  dest_cart :: _ 
+
+syntax
+  mk_cart :: _ 
+
+lemmas "TYDEF_cart_@intern" = typedef_hol2hollight 
+  [where a="a :: ('A, 'B) cart" and r=r ,
+   OF type_definition_cart]
+
+consts
+  "$" :: "('q_73536, 'q_73546) cart => nat => 'q_73536" ("$")
+
+defs
+  "$_def": "$ == %(u::('q_73536, 'q_73546) cart) ua::nat. dest_cart u (finite_index ua)"
+
+lemma "DEF_$": "$ = (%(u::('q_73536, 'q_73546) cart) ua::nat. dest_cart u (finite_index ua))"
+  by (import hollight "DEF_$")
+
+lemma CART_EQ: "(op =::bool => bool => bool)
+ ((op =::('A::type, 'B::type) cart => ('A::type, 'B::type) cart => bool)
+   (x::('A::type, 'B::type) cart) (y::('A::type, 'B::type) cart))
+ ((All::(nat => bool) => bool)
+   (%xa::nat.
+       (op -->::bool => bool => bool)
+        ((op &::bool => bool => bool)
+          ((op <=::nat => nat => bool) (1::nat) xa)
+          ((op <=::nat => nat => bool) xa
+            ((dimindex::('B::type => bool) => nat)
+              (UNIV::'B::type => bool))))
+        ((op =::'A::type => 'A::type => bool)
+          (($::('A::type, 'B::type) cart => nat => 'A::type) x xa)
+          (($::('A::type, 'B::type) cart => nat => 'A::type) y xa))))"
+  by (import hollight CART_EQ)
+
+definition
+  lambda :: "(nat => 'A) => ('A, 'B) cart"  where
+  "(op ==::((nat => 'A::type) => ('A::type, 'B::type) cart)
+        => ((nat => 'A::type) => ('A::type, 'B::type) cart) => prop)
+ (lambda::(nat => 'A::type) => ('A::type, 'B::type) cart)
+ (%u::nat => 'A::type.
+     (Eps::(('A::type, 'B::type) cart => bool) => ('A::type, 'B::type) cart)
+      (%f::('A::type, 'B::type) cart.
+          (All::(nat => bool) => bool)
+           (%i::nat.
+               (op -->::bool => bool => bool)
+                ((op &::bool => bool => bool)
+                  ((op <=::nat => nat => bool) (1::nat) i)
+                  ((op <=::nat => nat => bool) i
+                    ((dimindex::('B::type => bool) => nat)
+                      (UNIV::'B::type => bool))))
+                ((op =::'A::type => 'A::type => bool)
+                  (($::('A::type, 'B::type) cart => nat => 'A::type) f i)
+                  (u i)))))"
+
+lemma DEF_lambda: "(op =::((nat => 'A::type) => ('A::type, 'B::type) cart)
+       => ((nat => 'A::type) => ('A::type, 'B::type) cart) => bool)
+ (lambda::(nat => 'A::type) => ('A::type, 'B::type) cart)
+ (%u::nat => 'A::type.
+     (Eps::(('A::type, 'B::type) cart => bool) => ('A::type, 'B::type) cart)
+      (%f::('A::type, 'B::type) cart.
+          (All::(nat => bool) => bool)
+           (%i::nat.
+               (op -->::bool => bool => bool)
+                ((op &::bool => bool => bool)
+                  ((op <=::nat => nat => bool) (1::nat) i)
+                  ((op <=::nat => nat => bool) i
+                    ((dimindex::('B::type => bool) => nat)
+                      (UNIV::'B::type => bool))))
+                ((op =::'A::type => 'A::type => bool)
+                  (($::('A::type, 'B::type) cart => nat => 'A::type) f i)
+                  (u i)))))"
+  by (import hollight DEF_lambda)
+
+lemma LAMBDA_BETA: "(op ==>::prop => prop => prop)
+ ((Trueprop::bool => prop)
+   ((op &::bool => bool => bool)
+     ((op <=::nat => nat => bool) (1::nat) (x::nat))
+     ((op <=::nat => nat => bool) x
+       ((dimindex::('B::type => bool) => nat) (UNIV::'B::type => bool)))))
+ ((Trueprop::bool => prop)
+   ((op =::'A::type => 'A::type => bool)
+     (($::('A::type, 'B::type) cart => nat => 'A::type)
+       ((lambda::(nat => 'A::type) => ('A::type, 'B::type) cart)
+         (g::nat => 'A::type))
+       x)
+     (g x)))"
+  by (import hollight LAMBDA_BETA)
+
+lemma LAMBDA_UNIQUE: "(op =::bool => bool => bool)
+ ((All::(nat => bool) => bool)
+   (%i::nat.
+       (op -->::bool => bool => bool)
+        ((op &::bool => bool => bool)
+          ((op <=::nat => nat => bool) (1::nat) i)
+          ((op <=::nat => nat => bool) i
+            ((dimindex::('B::type => bool) => nat)
+              (UNIV::'B::type => bool))))
+        ((op =::'A::type => 'A::type => bool)
+          (($::('A::type, 'B::type) cart => nat => 'A::type)
+            (x::('A::type, 'B::type) cart) i)
+          ((xa::nat => 'A::type) i))))
+ ((op =::('A::type, 'B::type) cart => ('A::type, 'B::type) cart => bool)
+   ((lambda::(nat => 'A::type) => ('A::type, 'B::type) cart) xa) x)"
+  by (import hollight LAMBDA_UNIQUE)
+
+lemma LAMBDA_ETA: "lambda ($ (x::('q_73734, 'q_73738) cart)) = x"
+  by (import hollight LAMBDA_ETA)
+
+lemma FINITE_INDEX_INRANGE: "(Ex::(nat => bool) => bool)
+ (%xa::nat.
+     (op &::bool => bool => bool) ((op <=::nat => nat => bool) (1::nat) xa)
+      ((op &::bool => bool => bool)
+        ((op <=::nat => nat => bool) xa
+          ((dimindex::('N::type => bool) => nat) (UNIV::'N::type => bool)))
+        ((All::(('A::type, 'N::type) cart => bool) => bool)
+          (%xb::('A::type, 'N::type) cart.
+              (op =::'A::type => 'A::type => bool)
+               (($::('A::type, 'N::type) cart => nat => 'A::type) xb
+                 (x::nat))
+               (($::('A::type, 'N::type) cart => nat => 'A::type) xb xa)))))"
+  by (import hollight FINITE_INDEX_INRANGE)
+
+lemma CART_EQ_FULL: "((x::('A, 'N) cart) = (y::('A, 'N) cart)) = (ALL i::nat. $ x i = $ y i)"
+  by (import hollight CART_EQ_FULL)
+
+typedef (open) ('A, 'B) finite_sum = "{x::nat.
+ x : dotdot (NUMERAL (NUMERAL_BIT1 (0::nat)))
+      (dimindex UNIV + dimindex UNIV)}"  morphisms "dest_finite_sum" "mk_finite_sum"
+  apply (rule light_ex_imp_nonempty[where t="SOME x::nat.
+   x : dotdot (NUMERAL (NUMERAL_BIT1 (0::nat)))
+        (dimindex UNIV + dimindex UNIV)"])
+  by (import hollight TYDEF_finite_sum)
+
+syntax
+  dest_finite_sum :: _ 
+
+syntax
+  mk_finite_sum :: _ 
+
+lemmas "TYDEF_finite_sum_@intern" = typedef_hol2hollight 
+  [where a="a :: ('A, 'B) finite_sum" and r=r ,
+   OF type_definition_finite_sum]
+
+definition
+  pastecart :: "('A, 'M) cart => ('A, 'N) cart => ('A, ('M, 'N) finite_sum) cart"  where
+  "(op ==::(('A::type, 'M::type) cart
+         => ('A::type, 'N::type) cart
+            => ('A::type, ('M::type, 'N::type) finite_sum) cart)
+        => (('A::type, 'M::type) cart
+            => ('A::type, 'N::type) cart
+               => ('A::type, ('M::type, 'N::type) finite_sum) cart)
+           => prop)
+ (pastecart::('A::type, 'M::type) cart
+             => ('A::type, 'N::type) cart
+                => ('A::type, ('M::type, 'N::type) finite_sum) cart)
+ (%(u::('A::type, 'M::type) cart) ua::('A::type, 'N::type) cart.
+     (lambda::(nat => 'A::type)
+              => ('A::type, ('M::type, 'N::type) finite_sum) cart)
+      (%i::nat.
+          (If::bool => 'A::type => 'A::type => 'A::type)
+           ((op <=::nat => nat => bool) i
+             ((dimindex::('M::type => bool) => nat)
+               (UNIV::'M::type => bool)))
+           (($::('A::type, 'M::type) cart => nat => 'A::type) u i)
+           (($::('A::type, 'N::type) cart => nat => 'A::type) ua
+             ((op -::nat => nat => nat) i
+               ((dimindex::('M::type => bool) => nat)
+                 (UNIV::'M::type => bool))))))"
+
+lemma DEF_pastecart: "(op =::(('A::type, 'M::type) cart
+        => ('A::type, 'N::type) cart
+           => ('A::type, ('M::type, 'N::type) finite_sum) cart)
+       => (('A::type, 'M::type) cart
+           => ('A::type, 'N::type) cart
+              => ('A::type, ('M::type, 'N::type) finite_sum) cart)
+          => bool)
+ (pastecart::('A::type, 'M::type) cart
+             => ('A::type, 'N::type) cart
+                => ('A::type, ('M::type, 'N::type) finite_sum) cart)
+ (%(u::('A::type, 'M::type) cart) ua::('A::type, 'N::type) cart.
+     (lambda::(nat => 'A::type)
+              => ('A::type, ('M::type, 'N::type) finite_sum) cart)
+      (%i::nat.
+          (If::bool => 'A::type => 'A::type => 'A::type)
+           ((op <=::nat => nat => bool) i
+             ((dimindex::('M::type => bool) => nat)
+               (UNIV::'M::type => bool)))
+           (($::('A::type, 'M::type) cart => nat => 'A::type) u i)
+           (($::('A::type, 'N::type) cart => nat => 'A::type) ua
+             ((op -::nat => nat => nat) i
+               ((dimindex::('M::type => bool) => nat)
+                 (UNIV::'M::type => bool))))))"
+  by (import hollight DEF_pastecart)
+
+definition
+  fstcart :: "('A, ('M, 'N) finite_sum) cart => ('A, 'M) cart"  where
+  "fstcart == %u::('A, ('M, 'N) finite_sum) cart. lambda ($ u)"
+
+lemma DEF_fstcart: "fstcart = (%u::('A, ('M, 'N) finite_sum) cart. lambda ($ u))"
+  by (import hollight DEF_fstcart)
+
+definition
+  sndcart :: "('A, ('M, 'N) finite_sum) cart => ('A, 'N) cart"  where
+  "(op ==::(('A::type, ('M::type, 'N::type) finite_sum) cart
+         => ('A::type, 'N::type) cart)
+        => (('A::type, ('M::type, 'N::type) finite_sum) cart
+            => ('A::type, 'N::type) cart)
+           => prop)
+ (sndcart::('A::type, ('M::type, 'N::type) finite_sum) cart
+           => ('A::type, 'N::type) cart)
+ (%u::('A::type, ('M::type, 'N::type) finite_sum) cart.
+     (lambda::(nat => 'A::type) => ('A::type, 'N::type) cart)
+      (%i::nat.
+          ($::('A::type, ('M::type, 'N::type) finite_sum) cart
+              => nat => 'A::type)
+           u ((op +::nat => nat => nat) i
+               ((dimindex::('M::type => bool) => nat)
+                 (UNIV::'M::type => bool)))))"
+
+lemma DEF_sndcart: "(op =::(('A::type, ('M::type, 'N::type) finite_sum) cart
+        => ('A::type, 'N::type) cart)
+       => (('A::type, ('M::type, 'N::type) finite_sum) cart
+           => ('A::type, 'N::type) cart)
+          => bool)
+ (sndcart::('A::type, ('M::type, 'N::type) finite_sum) cart
+           => ('A::type, 'N::type) cart)
+ (%u::('A::type, ('M::type, 'N::type) finite_sum) cart.
+     (lambda::(nat => 'A::type) => ('A::type, 'N::type) cart)
+      (%i::nat.
+          ($::('A::type, ('M::type, 'N::type) finite_sum) cart
+              => nat => 'A::type)
+           u ((op +::nat => nat => nat) i
+               ((dimindex::('M::type => bool) => nat)
+                 (UNIV::'M::type => bool)))))"
+  by (import hollight DEF_sndcart)
+
+lemma FINITE_SUM_IMAGE: "(op =::(('A::type, 'B::type) finite_sum => bool)
+       => (('A::type, 'B::type) finite_sum => bool) => bool)
+ (UNIV::('A::type, 'B::type) finite_sum => bool)
+ ((op `::(nat => ('A::type, 'B::type) finite_sum)
+         => (nat => bool) => ('A::type, 'B::type) finite_sum => bool)
+   (mk_finite_sum::nat => ('A::type, 'B::type) finite_sum)
+   ((atLeastAtMost::nat => nat => nat => bool) (1::nat)
+     ((op +::nat => nat => nat)
+       ((dimindex::('A::type => bool) => nat) (UNIV::'A::type => bool))
+       ((dimindex::('B::type => bool) => nat) (UNIV::'B::type => bool)))))"
+  by (import hollight FINITE_SUM_IMAGE)
+
+lemma HAS_SIZE_1: "(HAS_SIZE::(unit => bool) => nat => bool) (UNIV::unit => bool) (1::nat)"
+  by (import hollight HAS_SIZE_1)
+
+typedef (open) N_2 = "{x. x : dotdot (NUMERAL (NUMERAL_BIT1 0))
+         (NUMERAL (NUMERAL_BIT0 (NUMERAL_BIT1 0)))}"  morphisms "dest_auto_define_finite_type_2" "mk_auto_define_finite_type_2"
+  apply (rule light_ex_imp_nonempty[where t="SOME x.
+   x : dotdot (NUMERAL (NUMERAL_BIT1 0))
+        (NUMERAL (NUMERAL_BIT0 (NUMERAL_BIT1 0)))"])
+  by (import hollight TYDEF_2)
+
+syntax
+  dest_auto_define_finite_type_2 :: _ 
+
+syntax
+  mk_auto_define_finite_type_2 :: _ 
+
+lemmas "TYDEF_2_@intern" = typedef_hol2hollight 
+  [where a="a :: N_2" and r=r ,
+   OF type_definition_N_2]
+
+typedef (open) N_3 = "{x. x : dotdot (NUMERAL (NUMERAL_BIT1 0))
+         (NUMERAL (NUMERAL_BIT1 (NUMERAL_BIT1 0)))}"  morphisms "dest_auto_define_finite_type_3" "mk_auto_define_finite_type_3"
+  apply (rule light_ex_imp_nonempty[where t="SOME x.
+   x : dotdot (NUMERAL (NUMERAL_BIT1 0))
+        (NUMERAL (NUMERAL_BIT1 (NUMERAL_BIT1 0)))"])
+  by (import hollight TYDEF_3)
+
+syntax
+  dest_auto_define_finite_type_3 :: _ 
+
+syntax
+  mk_auto_define_finite_type_3 :: _ 
+
+lemmas "TYDEF_3_@intern" = typedef_hol2hollight 
+  [where a="a :: N_3" and r=r ,
+   OF type_definition_N_3]
+
+lemma FINITE_CART: "(op ==>::prop => prop => prop)
+ ((all::(nat => prop) => prop)
+   (%i::nat.
+       (op ==>::prop => prop => prop)
+        ((Trueprop::bool => prop)
+          ((op &::bool => bool => bool)
+            ((op <=::nat => nat => bool) (1::nat) i)
+            ((op <=::nat => nat => bool) i
+              ((dimindex::('N::type => bool) => nat)
+                (UNIV::'N::type => bool)))))
+        ((Trueprop::bool => prop)
+          ((finite::('A::type => bool) => bool)
+            ((Collect::('A::type => bool) => 'A::type => bool)
+              (%u::'A::type.
+                  (Ex::('A::type => bool) => bool)
+                   (%x::'A::type.
+                       (op &::bool => bool => bool)
+                        ((P::nat => 'A::type => bool) i x)
+                        ((op =::'A::type => 'A::type => bool) u x))))))))
+ ((Trueprop::bool => prop)
+   ((finite::(('A::type, 'N::type) cart => bool) => bool)
+     ((Collect::(('A::type, 'N::type) cart => bool)
+                => ('A::type, 'N::type) cart => bool)
+       (%u::('A::type, 'N::type) cart.
+           (Ex::(('A::type, 'N::type) cart => bool) => bool)
+            (%v::('A::type, 'N::type) cart.
+                (op &::bool => bool => bool)
+                 ((All::(nat => bool) => bool)
+                   (%i::nat.
+                       (op -->::bool => bool => bool)
+                        ((op &::bool => bool => bool)
+                          ((op <=::nat => nat => bool) (1::nat) i)
+                          ((op <=::nat => nat => bool) i
+                            ((dimindex::('N::type => bool) => nat)
+                              (UNIV::'N::type => bool))))
+                        (P i (($::('A::type, 'N::type) cart
+                                  => nat => 'A::type)
+                               v i))))
+                 ((op =::('A::type, 'N::type) cart
+                         => ('A::type, 'N::type) cart => bool)
+                   u v))))))"
+  by (import hollight FINITE_CART)
+
+definition
+  vector :: "'A list => ('A, 'N) cart"  where
+  "(op ==::('A::type list => ('A::type, 'N::type) cart)
+        => ('A::type list => ('A::type, 'N::type) cart) => prop)
+ (vector::'A::type list => ('A::type, 'N::type) cart)
+ (%u::'A::type list.
+     (lambda::(nat => 'A::type) => ('A::type, 'N::type) cart)
+      (%i::nat.
+          (op !::'A::type list => nat => 'A::type) u
+           ((op -::nat => nat => nat) i (1::nat))))"
+
+lemma DEF_vector: "(op =::('A::type list => ('A::type, 'N::type) cart)
+       => ('A::type list => ('A::type, 'N::type) cart) => bool)
+ (vector::'A::type list => ('A::type, 'N::type) cart)
+ (%u::'A::type list.
+     (lambda::(nat => 'A::type) => ('A::type, 'N::type) cart)
+      (%i::nat.
+          (op !::'A::type list => nat => 'A::type) u
+           ((op -::nat => nat => nat) i (1::nat))))"
+  by (import hollight DEF_vector)
+
+definition
+  CASEWISE :: "(('q_74835 => 'q_74839) * ('q_74840 => 'q_74835 => 'q_74799)) list
+=> 'q_74840 => 'q_74839 => 'q_74799"  where
+  "CASEWISE ==
+SOME CASEWISE::(('q_74835 => 'q_74839) *
+                ('q_74840 => 'q_74835 => 'q_74799)) list
+               => 'q_74840 => 'q_74839 => 'q_74799.
+   (ALL (f::'q_74840) x::'q_74839.
+       CASEWISE [] f x = (SOME y::'q_74799. True)) &
+   (ALL (h::('q_74835 => 'q_74839) * ('q_74840 => 'q_74835 => 'q_74799))
+       (t::(('q_74835 => 'q_74839) *
+            ('q_74840 => 'q_74835 => 'q_74799)) list)
+       (f::'q_74840) x::'q_74839.
+       CASEWISE (h # t) f x =
+       (if EX y::'q_74835. fst h y = x
+        then snd h f (SOME y::'q_74835. fst h y = x) else CASEWISE t f x))"
+
+lemma DEF_CASEWISE: "CASEWISE =
+(SOME CASEWISE::(('q_74835 => 'q_74839) *
+                 ('q_74840 => 'q_74835 => 'q_74799)) list
+                => 'q_74840 => 'q_74839 => 'q_74799.
+    (ALL (f::'q_74840) x::'q_74839.
+        CASEWISE [] f x = (SOME y::'q_74799. True)) &
+    (ALL (h::('q_74835 => 'q_74839) * ('q_74840 => 'q_74835 => 'q_74799))
+        (t::(('q_74835 => 'q_74839) *
+             ('q_74840 => 'q_74835 => 'q_74799)) list)
+        (f::'q_74840) x::'q_74839.
+        CASEWISE (h # t) f x =
+        (if EX y::'q_74835. fst h y = x
+         then snd h f (SOME y::'q_74835. fst h y = x) else CASEWISE t f x)))"
+  by (import hollight DEF_CASEWISE)
+
+definition
+  admissible :: "('q_75137 => 'q_75130 => bool)
+=> (('q_75137 => 'q_75133) => 'q_75143 => bool)
+   => ('q_75143 => 'q_75130)
+      => (('q_75137 => 'q_75133) => 'q_75143 => 'q_75138) => bool"  where
+  "admissible ==
+%(u::'q_75137 => 'q_75130 => bool)
+   (ua::('q_75137 => 'q_75133) => 'q_75143 => bool)
+   (ub::'q_75143 => 'q_75130)
+   uc::('q_75137 => 'q_75133) => 'q_75143 => 'q_75138.
+   ALL (f::'q_75137 => 'q_75133) (g::'q_75137 => 'q_75133) a::'q_75143.
+      ua f a & ua g a & (ALL z::'q_75137. u z (ub a) --> f z = g z) -->
+      uc f a = uc g a"
+
+lemma DEF_admissible: "admissible =
+(%(u::'q_75137 => 'q_75130 => bool)
+    (ua::('q_75137 => 'q_75133) => 'q_75143 => bool)
+    (ub::'q_75143 => 'q_75130)
+    uc::('q_75137 => 'q_75133) => 'q_75143 => 'q_75138.
+    ALL (f::'q_75137 => 'q_75133) (g::'q_75137 => 'q_75133) a::'q_75143.
+       ua f a & ua g a & (ALL z::'q_75137. u z (ub a) --> f z = g z) -->
+       uc f a = uc g a)"
+  by (import hollight DEF_admissible)
+
+definition
+  tailadmissible :: "('A => 'A => bool)
+=> (('A => 'B) => 'P => bool)
+   => ('P => 'A) => (('A => 'B) => 'P => 'B) => bool"  where
+  "tailadmissible ==
+%(u::'A => 'A => bool) (ua::('A => 'B) => 'P => bool) (ub::'P => 'A)
+   uc::('A => 'B) => 'P => 'B.
+   EX (P::('A => 'B) => 'P => bool) (G::('A => 'B) => 'P => 'A)
+      H::('A => 'B) => 'P => 'B.
+      (ALL (f::'A => 'B) (a::'P) y::'A.
+          P f a & u y (G f a) --> u y (ub a)) &
+      (ALL (f::'A => 'B) (g::'A => 'B) a::'P.
+          (ALL z::'A. u z (ub a) --> f z = g z) -->
+          P f a = P g a & G f a = G g a & H f a = H g a) &
+      (ALL (f::'A => 'B) a::'P.
+          ua f a --> uc f a = (if P f a then f (G f a) else H f a))"
+
+lemma DEF_tailadmissible: "tailadmissible =
+(%(u::'A => 'A => bool) (ua::('A => 'B) => 'P => bool) (ub::'P => 'A)
+    uc::('A => 'B) => 'P => 'B.
+    EX (P::('A => 'B) => 'P => bool) (G::('A => 'B) => 'P => 'A)
+       H::('A => 'B) => 'P => 'B.
+       (ALL (f::'A => 'B) (a::'P) y::'A.
+           P f a & u y (G f a) --> u y (ub a)) &
+       (ALL (f::'A => 'B) (g::'A => 'B) a::'P.
+           (ALL z::'A. u z (ub a) --> f z = g z) -->
+           P f a = P g a & G f a = G g a & H f a = H g a) &
+       (ALL (f::'A => 'B) a::'P.
+           ua f a --> uc f a = (if P f a then f (G f a) else H f a)))"
+  by (import hollight DEF_tailadmissible)
+
+definition
+  superadmissible :: "('q_75287 => 'q_75287 => bool)
+=> (('q_75287 => 'q_75289) => 'q_75295 => bool)
+   => ('q_75295 => 'q_75287)
+      => (('q_75287 => 'q_75289) => 'q_75295 => 'q_75289) => bool"  where
+  "superadmissible ==
+%(u::'q_75287 => 'q_75287 => bool)
+   (ua::('q_75287 => 'q_75289) => 'q_75295 => bool)
+   (ub::'q_75295 => 'q_75287)
+   uc::('q_75287 => 'q_75289) => 'q_75295 => 'q_75289.
+   admissible u (%(f::'q_75287 => 'q_75289) a::'q_75295. True) ub ua -->
+   tailadmissible u ua ub uc"
+
+lemma DEF_superadmissible: "superadmissible =
+(%(u::'q_75287 => 'q_75287 => bool)
+    (ua::('q_75287 => 'q_75289) => 'q_75295 => bool)
+    (ub::'q_75295 => 'q_75287)
+    uc::('q_75287 => 'q_75289) => 'q_75295 => 'q_75289.
+    admissible u (%(f::'q_75287 => 'q_75289) a::'q_75295. True) ub ua -->
+    tailadmissible u ua ub uc)"
+  by (import hollight DEF_superadmissible)
+
+lemma MATCH_SEQPATTERN: "_MATCH (x::'q_75330)
+ (_SEQPATTERN (r::'q_75330 => 'q_75323 => bool)
+   (s::'q_75330 => 'q_75323 => bool)) =
+(if Ex (r x) then _MATCH x r else _MATCH x s)"
+  by (import hollight MATCH_SEQPATTERN)
+
+lemma ADMISSIBLE_CONST: "admissible (u_556::'q_75351 => 'q_75350 => bool)
+ (x::('q_75351 => 'q_75352) => 'q_75353 => bool) (xa::'q_75353 => 'q_75350)
+ (%f::'q_75351 => 'q_75352. xb::'q_75353 => 'q_75354)"
+  by (import hollight ADMISSIBLE_CONST)
+
+lemma ADMISSIBLE_BASE: "(!!(f::'A => 'B) a::'P.
+    (xa::('A => 'B) => 'P => bool) f a
+    ==> (x::'A => 'A => bool) ((xc::'P => 'A) a) ((xb::'P => 'A) a))
+==> admissible x xa xb (%(f::'A => 'B) x::'P. f (xc x))"
+  by (import hollight ADMISSIBLE_BASE)
+
+lemma ADMISSIBLE_COMB: "admissible (x::'A => 'A => bool) (xa::('A => 'B) => 'P => bool)
+ (xb::'P => 'A) (xc::('A => 'B) => 'P => 'C => 'D) &
+admissible x xa xb (xd::('A => 'B) => 'P => 'C)
+==> admissible x xa xb (%(f::'A => 'B) x::'P. xc f x (xd f x))"
+  by (import hollight ADMISSIBLE_COMB)
+
+lemma ADMISSIBLE_RAND: "admissible (x::'A => 'A => bool) (xa::('A => 'B) => 'P => bool)
+ (xb::'P => 'A) (xd::('A => 'B) => 'P => 'C)
+==> admissible x xa xb
+     (%(f::'A => 'B) x::'P. (xc::'P => 'C => 'D) x (xd f x))"
+  by (import hollight ADMISSIBLE_RAND)
+
+lemma ADMISSIBLE_LAMBDA: "admissible (x::'A => 'A => bool)
+ (%f::'A => 'B.
+     SOME fa::'C * 'P => bool.
+        ALL (u::'C) x::'P. fa (u, x) = (xa::('A => 'B) => 'P => bool) f x)
+ (SOME f::'C * 'P => 'A. ALL (u::'C) x::'P. f (u, x) = (xb::'P => 'A) x)
+ (%f::'A => 'B.
+     SOME fa::'C * 'P => bool.
+        ALL (u::'C) x::'P.
+           fa (u, x) = (xc::('A => 'B) => 'C => 'P => bool) f u x)
+==> admissible x xa xb (%(f::'A => 'B) (x::'P) u::'C. xc f u x)"
+  by (import hollight ADMISSIBLE_LAMBDA)
+
+lemma ADMISSIBLE_NEST: "admissible (x::'A => 'A => bool) (xa::('A => 'B) => 'P => bool)
+ (xb::'P => 'A) (xc::('A => 'B) => 'P => 'A) &
+(ALL (f::'A => 'B) a::'P. xa f a --> x (xc f a) (xb a))
+==> admissible x xa xb (%(f::'A => 'B) x::'P. f (xc f x))"
+  by (import hollight ADMISSIBLE_NEST)
+
+lemma ADMISSIBLE_COND: "admissible (u_556::'q_75688 => 'q_75687 => bool)
+ (p::('q_75688 => 'q_75719) => 'P => bool) (s::'P => 'q_75687)
+ (P::('q_75688 => 'q_75719) => 'P => bool) &
+admissible u_556 (%(f::'q_75688 => 'q_75719) x::'P. p f x & P f x) s
+ (h::('q_75688 => 'q_75719) => 'P => 'q_75744) &
+admissible u_556 (%(f::'q_75688 => 'q_75719) x::'P. p f x & ~ P f x) s
+ (k::('q_75688 => 'q_75719) => 'P => 'q_75744)
+==> admissible u_556 p s
+     (%(f::'q_75688 => 'q_75719) x::'P. if P f x then h f x else k f x)"
+  by (import hollight ADMISSIBLE_COND)
+
+lemma ADMISSIBLE_MATCH: "admissible (x::'q_75790 => 'q_75789 => bool)
+ (xa::('q_75790 => 'q_75791) => 'P => bool) (xb::'P => 'q_75789)
+ (xc::('q_75790 => 'q_75791) => 'P => 'q_75826) &
+admissible x xa xb
+ (%(f::'q_75790 => 'q_75791) x::'P.
+     (c::('q_75790 => 'q_75791) => 'P => 'q_75826 => 'q_75823 => bool) f x
+      (xc f x))
+==> admissible x xa xb
+     (%(f::'q_75790 => 'q_75791) x::'P. _MATCH (xc f x) (c f x))"
+  by (import hollight ADMISSIBLE_MATCH)
+
+lemma ADMISSIBLE_SEQPATTERN: "admissible (x::'q_75867 => 'q_75866 => bool)
+ (xa::('q_75867 => 'q_75929) => 'P => bool) (xb::'P => 'q_75866)
+ (%(f::'q_75867 => 'q_75929) x::'P.
+     Ex ((xc::('q_75867 => 'q_75929) => 'P => 'q_75955 => 'q_75945 => bool)
+          f x ((xe::('q_75867 => 'q_75929) => 'P => 'q_75955) f x))) &
+admissible x
+ (%(f::'q_75867 => 'q_75929) x::'P. xa f x & Ex (xc f x (xe f x))) xb
+ (%(f::'q_75867 => 'q_75929) x::'P. xc f x (xe f x)) &
+admissible x
+ (%(f::'q_75867 => 'q_75929) x::'P. xa f x & ~ Ex (xc f x (xe f x))) xb
+ (%(f::'q_75867 => 'q_75929) x::'P.
+     (xd::('q_75867 => 'q_75929) => 'P => 'q_75955 => 'q_75945 => bool) f x
+      (xe f x))
+==> admissible x xa xb
+     (%(f::'q_75867 => 'q_75929) x::'P.
+         _SEQPATTERN (xc f x) (xd f x) (xe f x))"
+  by (import hollight ADMISSIBLE_SEQPATTERN)
+
+lemma ADMISSIBLE_UNGUARDED_PATTERN: "admissible (u_556::'q_76041 => 'q_76040 => bool)
+ (p::('q_76041 => 'q_76088) => 'P => bool) (s::'P => 'q_76040)
+ (pat::('q_76041 => 'q_76088) => 'P => 'q_76121) &
+admissible u_556 p s (e::('q_76041 => 'q_76088) => 'P => 'q_76121) &
+admissible u_556 (%(f::'q_76041 => 'q_76088) x::'P. p f x & pat f x = e f x)
+ s (t::('q_76041 => 'q_76088) => 'P => 'q_76128) &
+admissible u_556 (%(f::'q_76041 => 'q_76088) x::'P. p f x & pat f x = e f x)
+ s (y::('q_76041 => 'q_76088) => 'P => 'q_76128)
+==> admissible u_556 p s
+     (%(f::'q_76041 => 'q_76088) x::'P.
+         _UNGUARDED_PATTERN (pat f x = e f x) (t f x = y f x))"
+  by (import hollight ADMISSIBLE_UNGUARDED_PATTERN)
+
+lemma ADMISSIBLE_GUARDED_PATTERN: "admissible (u_556::'q_76215 => 'q_76214 => bool)
+ (p::('q_76215 => 'q_76292) => 'P => bool) (s::'P => 'q_76214)
+ (pat::('q_76215 => 'q_76292) => 'P => 'q_76330) &
+admissible u_556 p s (e::('q_76215 => 'q_76292) => 'P => 'q_76330) &
+admissible u_556
+ (%(f::'q_76215 => 'q_76292) x::'P.
+     p f x &
+     pat f x = e f x & (q::('q_76215 => 'q_76292) => 'P => bool) f x)
+ s (t::('q_76215 => 'q_76292) => 'P => 'q_76339) &
+admissible u_556 (%(f::'q_76215 => 'q_76292) x::'P. p f x & pat f x = e f x)
+ s q &
+admissible u_556
+ (%(f::'q_76215 => 'q_76292) x::'P. p f x & pat f x = e f x & q f x) s
+ (y::('q_76215 => 'q_76292) => 'P => 'q_76339)
+==> admissible u_556 p s
+     (%(f::'q_76215 => 'q_76292) x::'P.
+         _GUARDED_PATTERN (pat f x = e f x) (q f x) (t f x = y f x))"
+  by (import hollight ADMISSIBLE_GUARDED_PATTERN)
+
+lemma ADMISSIBLE_NSUM: "admissible (x::'B => 'A => bool)
+ (%f::'B => 'C.
+     SOME fa::nat * 'P => bool.
+        ALL (k::nat) x::'P.
+           fa (k, x) =
+           ((xd::'P => nat) x <= k &
+            k <= (xe::'P => nat) x & (xa::('B => 'C) => 'P => bool) f x))
+ (SOME f::nat * 'P => 'A. ALL (k::nat) x::'P. f (k, x) = (xb::'P => 'A) x)
+ (%f::'B => 'C.
+     SOME fa::nat * 'P => nat.
+        ALL (k::nat) x::'P.
+           fa (k, x) = (xc::('B => 'C) => 'P => nat => nat) f x k)
+==> admissible x xa xb (%(f::'B => 'C) x::'P. nsum {xd x..xe x} (xc f x))"
+  by (import hollight ADMISSIBLE_NSUM)
+
+lemma ADMISSIBLE_SUM: "admissible (x::'B => 'A => bool)
+ (%f::'B => 'C.
+     SOME fa::nat * 'P => bool.
+        ALL (k::nat) x::'P.
+           fa (k, x) =
+           ((xd::'P => nat) x <= k &
+            k <= (xe::'P => nat) x & (xa::('B => 'C) => 'P => bool) f x))
+ (SOME f::nat * 'P => 'A. ALL (k::nat) x::'P. f (k, x) = (xb::'P => 'A) x)
+ (%f::'B => 'C.
+     SOME fa::nat * 'P => hollight.real.
+        ALL (k::nat) x::'P.
+           fa (k, x) = (xc::('B => 'C) => 'P => nat => hollight.real) f x k)
+==> admissible x xa xb
+     (%(f::'B => 'C) x::'P. hollight.sum {xd x..xe x} (xc f x))"
+  by (import hollight ADMISSIBLE_SUM)
+
+lemma ADMISSIBLE_MAP: "admissible (x::'A => 'q_76632 => bool) (xa::('A => 'B) => 'P => bool)
+ (xb::'P => 'q_76632) (xd::('A => 'B) => 'P => 'q_76647 list) &
+admissible x
+ (%f::'A => 'B.
+     SOME fa::'q_76647 * 'P => bool.
+        ALL (y::'q_76647) x::'P. fa (y, x) = (xa f x & y : set (xd f x)))
+ (SOME f::'q_76647 * 'P => 'q_76632.
+     ALL (y::'q_76647) x::'P. f (y, x) = xb x)
+ (%f::'A => 'B.
+     SOME fa::'q_76647 * 'P => 'q_76641.
+        ALL (y::'q_76647) x::'P.
+           fa (y, x) = (xc::('A => 'B) => 'P => 'q_76647 => 'q_76641) f x y)
+==> admissible x xa xb (%(f::'A => 'B) x::'P. map (xc f x) (xd f x))"
+  by (import hollight ADMISSIBLE_MAP)
+
+lemma ADMISSIBLE_MATCH_SEQPATTERN: "admissible (x::'q_76705 => 'q_76704 => bool)
+ (xa::('q_76705 => 'q_76770) => 'P => bool) (xb::'P => 'q_76704)
+ (%(f::'q_76705 => 'q_76770) x::'P.
+     Ex ((xc::('q_76705 => 'q_76770) => 'P => 'q_76825 => 'q_76794 => bool)
+          f x ((xe::('q_76705 => 'q_76770) => 'P => 'q_76825) f x))) &
+admissible x
+ (%(f::'q_76705 => 'q_76770) x::'P. xa f x & Ex (xc f x (xe f x))) xb
+ (%(f::'q_76705 => 'q_76770) x::'P. _MATCH (xe f x) (xc f x)) &
+admissible x
+ (%(f::'q_76705 => 'q_76770) x::'P. xa f x & ~ Ex (xc f x (xe f x))) xb
+ (%(f::'q_76705 => 'q_76770) x::'P.
+     _MATCH (xe f x)
+      ((xd::('q_76705 => 'q_76770) => 'P => 'q_76825 => 'q_76794 => bool) f
+        x))
+==> admissible x xa xb
+     (%(x::'q_76705 => 'q_76770) xa::'P.
+         _MATCH (xe x xa) (_SEQPATTERN (xc x xa) (xd x xa)))"
+  by (import hollight ADMISSIBLE_MATCH_SEQPATTERN)
+
+lemma ADMISSIBLE_IMP_SUPERADMISSIBLE: "admissible (x::'A => 'A => bool) (xa::('A => 'B) => 'P => bool)
+ (xb::'P => 'A) (xc::('A => 'B) => 'P => 'B)
+==> superadmissible x xa xb xc"
+  by (import hollight ADMISSIBLE_IMP_SUPERADMISSIBLE)
+
+lemma SUPERADMISSIBLE_CONST: "superadmissible (u_556::'q_76904 => 'q_76904 => bool)
+ (p::('q_76904 => 'q_76906) => 'q_76905 => bool) (s::'q_76905 => 'q_76904)
+ (%f::'q_76904 => 'q_76906. c::'q_76905 => 'q_76906)"
+  by (import hollight SUPERADMISSIBLE_CONST)
+
+lemma SUPERADMISSIBLE_TAIL: "admissible (x::'A => 'A => bool) (xa::('A => 'B) => 'P => bool)
+ (xb::'P => 'A) (xc::('A => 'B) => 'P => 'A) &
+(ALL (f::'A => 'B) a::'P.
+    xa f a --> (ALL y::'A. x y (xc f a) --> x y (xb a)))
+==> superadmissible x xa xb (%(f::'A => 'B) x::'P. f (xc f x))"
+  by (import hollight SUPERADMISSIBLE_TAIL)
+
+lemma SUPERADMISSIBLE_COND: "admissible (x::'A => 'A => bool) (xa::('A => 'B) => 'P => bool)
+ (xc::'P => 'A) (xb::('A => 'B) => 'P => bool) &
+superadmissible x (%(f::'A => 'B) x::'P. xa f x & xb f x) xc
+ (xd::('A => 'B) => 'P => 'B) &
+superadmissible x (%(f::'A => 'B) x::'P. xa f x & ~ xb f x) xc
+ (xe::('A => 'B) => 'P => 'B)
+==> superadmissible x xa xc
+     (%(f::'A => 'B) x::'P. if xb f x then xd f x else xe f x)"
+  by (import hollight SUPERADMISSIBLE_COND)
+
+lemma SUPERADMISSIBLE_MATCH_SEQPATTERN: "admissible (x::'q_77225 => 'q_77225 => bool)
+ (xa::('q_77225 => 'q_77341) => 'P => bool) (xb::'P => 'q_77225)
+ (%(f::'q_77225 => 'q_77341) x::'P.
+     Ex ((xc::('q_77225 => 'q_77341) => 'P => 'q_77340 => 'q_77341 => bool)
+          f x ((xe::('q_77225 => 'q_77341) => 'P => 'q_77340) f x))) &
+superadmissible x
+ (%(f::'q_77225 => 'q_77341) x::'P. xa f x & Ex (xc f x (xe f x))) xb
+ (%(f::'q_77225 => 'q_77341) x::'P. _MATCH (xe f x) (xc f x)) &
+superadmissible x
+ (%(f::'q_77225 => 'q_77341) x::'P. xa f x & ~ Ex (xc f x (xe f x))) xb
+ (%(f::'q_77225 => 'q_77341) x::'P.
+     _MATCH (xe f x)
+      ((xd::('q_77225 => 'q_77341) => 'P => 'q_77340 => 'q_77341 => bool) f
+        x))
+==> superadmissible x xa xb
+     (%(x::'q_77225 => 'q_77341) xa::'P.
+         _MATCH (xe x xa) (_SEQPATTERN (xc x xa) (xd x xa)))"
+  by (import hollight SUPERADMISSIBLE_MATCH_SEQPATTERN)
+
+lemma SUPERADMISSIBLE_MATCH_UNGUARDED_PATTERN: "(ALL (f::'A => 'B) (a::'P) (t::'Q) u::'Q.
+    (p::('A => 'B) => 'P => bool) f a &
+    (pat::'Q => 'D) t = (e::'P => 'D) a & pat u = e a -->
+    (arg::'P => 'Q => 'A) a t = arg a u) &
+(ALL (f::'A => 'B) (a::'P) t::'Q.
+    p f a & pat t = e a -->
+    (ALL y::'A.
+        (u_556::'A => 'A => bool) y (arg a t) -->
+        u_556 y ((s::'P => 'A) a)))
+==> superadmissible u_556 p s
+     (%(f::'A => 'B) x::'P.
+         _MATCH (e x)
+          (%(u::'D) v::'B.
+              EX t::'Q. _UNGUARDED_PATTERN (pat t = u) (f (arg x t) = v)))"
+  by (import hollight SUPERADMISSIBLE_MATCH_UNGUARDED_PATTERN)
+
+lemma SUPERADMISSIBLE_MATCH_GUARDED_PATTERN: "(ALL (f::'A => 'B) (a::'P) (t::'Q) u::'Q.
+    (p::('A => 'B) => 'P => bool) f a &
+    (pat::'Q => 'D) t = (e::'P => 'D) a &
+    (q::'P => 'Q => bool) a t & pat u = e a & q a u -->
+    (arg::'P => 'Q => 'A) a t = arg a u) &
+(ALL (f::'A => 'B) (a::'P) t::'Q.
+    p f a & q a t & pat t = e a -->
+    (ALL y::'A.
+        (u_556::'A => 'A => bool) y (arg a t) -->
+        u_556 y ((s::'P => 'A) a)))
+==> superadmissible u_556 p s
+     (%(f::'A => 'B) x::'P.
+         _MATCH (e x)
+          (%(u::'D) v::'B.
+              EX t::'Q.
+                 _GUARDED_PATTERN (pat t = u) (q x t) (f (arg x t) = v)))"
+  by (import hollight SUPERADMISSIBLE_MATCH_GUARDED_PATTERN)
+
+lemma cth: "[| !!(c::'q_78547) (x::'A) y::'A.
+      (p1::'A => 'q_78536) x = (p1'::'A => 'q_78536) y
+      ==> (p2::'q_78547 => 'A => 'q_78541) c x =
+          (p2'::'q_78547 => 'A => 'q_78541) c y;
+   p1' (x::'A) = p1 (y::'A) |]
+==> p2' (c::'q_78547) x = p2 c y"
+  by (import hollight cth)
+
+lemma SUPERADMISSIBLE_T: "superadmissible (u_556::'q_78694 => 'q_78694 => bool)
+ (%(f::'q_78694 => 'q_78696) x::'q_78700. True) (s::'q_78700 => 'q_78694)
+ (t::('q_78694 => 'q_78696) => 'q_78700 => 'q_78696) =
+tailadmissible u_556 (%(f::'q_78694 => 'q_78696) x::'q_78700. True) s t"
+  by (import hollight SUPERADMISSIBLE_T)
+
+lemma elemma0: "(ALL z::'q_78985 * 'q_78984.
+    (f::'q_78985 * 'q_78984 => 'q_78975) z =
+    (g::'q_78985 * 'q_78984 => 'q_78975) z) =
+(ALL (x::'q_78985) y::'q_78984. f (x, y) = g (x, y)) &
+(P::'q_79002 * 'q_79001 => 'q_78994) =
+(SOME f::'q_79002 * 'q_79001 => 'q_78994.
+    ALL (x::'q_79002) y::'q_79001. f (x, y) = P (x, y))"
+  by (import hollight elemma0)
+
+;end_setup
+
+end
+
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL_Light/Generated/hollight.imp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL_Light/Generated/hollight.imp	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,2335 @@
+import
+
+import_segment "hollight"
+
+def_maps
+  "vector" > "vector_def"
+  "treal_of_num" > "treal_of_num_def"
+  "treal_neg" > "treal_neg_def"
+  "treal_mul" > "treal_mul_def"
+  "treal_le" > "treal_le_def"
+  "treal_inv" > "treal_inv_def"
+  "treal_eq" > "treal_eq_def"
+  "treal_add" > "treal_add_def"
+  "tailadmissible" > "tailadmissible_def"
+  "support" > "support_def"
+  "superadmissible" > "superadmissible_def"
+  "sum" > "sum_def"
+  "sndcart" > "sndcart_def"
+  "rem" > "rem_def"
+  "real_sub" > "real_sub_def"
+  "real_sgn" > "real_sgn_def"
+  "real_pow" > "real_pow_def"
+  "real_of_num" > "real_of_num_def"
+  "real_neg" > "real_neg_def"
+  "real_mul" > "real_mul_def"
+  "real_mod" > "real_mod_def"
+  "real_min" > "real_min_def"
+  "real_max" > "real_max_def"
+  "real_lt" > "real_lt_def"
+  "real_le" > "real_le_def"
+  "real_inv" > "real_inv_def"
+  "real_gt" > "real_gt_def"
+  "real_ge" > "real_ge_def"
+  "real_div" > "real_div_def"
+  "real_add" > "real_add_def"
+  "real_abs" > "real_abs_def"
+  "pastecart" > "pastecart_def"
+  "pairwise" > "pairwise_def"
+  "num_of_int" > "num_of_int_def"
+  "num_mod" > "num_mod_def"
+  "num_gcd" > "num_gcd_def"
+  "num_divides" > "num_divides_def"
+  "num_coprime" > "num_coprime_def"
+  "nsum" > "nsum_def"
+  "neutral" > "neutral_def"
+  "nadd_rinv" > "nadd_rinv_def"
+  "nadd_of_num" > "nadd_of_num_def"
+  "nadd_mul" > "nadd_mul_def"
+  "nadd_le" > "nadd_le_def"
+  "nadd_inv" > "nadd_inv_def"
+  "nadd_eq" > "nadd_eq_def"
+  "nadd_add" > "nadd_add_def"
+  "monoidal" > "monoidal_def"
+  "minimal" > "minimal_def"
+  "lambda" > "lambda_def"
+  "iterate" > "iterate_def"
+  "is_nadd" > "is_nadd_def"
+  "integer" > "integer_def"
+  "int_sub" > "int_sub_def"
+  "int_sgn" > "int_sgn_def"
+  "int_pow" > "int_pow_def"
+  "int_of_num" > "int_of_num_def"
+  "int_neg" > "int_neg_def"
+  "int_mul" > "int_mul_def"
+  "int_mod" > "int_mod_def"
+  "int_min" > "int_min_def"
+  "int_max" > "int_max_def"
+  "int_lt" > "int_lt_def"
+  "int_le" > "int_le_def"
+  "int_gt" > "int_gt_def"
+  "int_ge" > "int_ge_def"
+  "int_gcd" > "int_gcd_def"
+  "int_divides" > "int_divides_def"
+  "int_coprime" > "int_coprime_def"
+  "int_add" > "int_add_def"
+  "int_abs" > "int_abs_def"
+  "hreal_of_num" > "hreal_of_num_def"
+  "hreal_mul" > "hreal_mul_def"
+  "hreal_le" > "hreal_le_def"
+  "hreal_inv" > "hreal_inv_def"
+  "hreal_add" > "hreal_add_def"
+  "fstcart" > "fstcart_def"
+  "eqeq" > "eqeq_def"
+  "div" > "div_def"
+  "dist" > "dist_def"
+  "dimindex" > "dimindex_def"
+  "admissible" > "admissible_def"
+  "_UNGUARDED_PATTERN" > "_UNGUARDED_PATTERN_def"
+  "_SEQPATTERN" > "_SEQPATTERN_def"
+  "_MATCH" > "_MATCH_def"
+  "_GUARDED_PATTERN" > "_GUARDED_PATTERN_def"
+  "_FUNCTION" > "_FUNCTION_def"
+  "_FALSITY_" > "_FALSITY__def"
+  "_11937" > "_11937_def"
+  "ZRECSPACE" > "ZRECSPACE_def"
+  "ZCONSTR" > "ZCONSTR_def"
+  "ZBOT" > "ZBOT_def"
+  "UNCURRY" > "UNCURRY_def"
+  "SURJ" > "SURJ_def"
+  "SING" > "SING_def"
+  "REST" > "REST_def"
+  "PASSOC" > "PASSOC_def"
+  "PAIRWISE" > "PAIRWISE_def"
+  "NUM_REP" > "NUM_REP_def"
+  "NUMSUM" > "NUMSUM_def"
+  "NUMSND" > "NUMSND_def"
+  "NUMRIGHT" > "NUMRIGHT_def"
+  "NUMPAIR" > "NUMPAIR_def"
+  "NUMLEFT" > "NUMLEFT_def"
+  "NUMFST" > "NUMFST_def"
+  "LET_END" > "LET_END_def"
+  "ITSET" > "ITSET_def"
+  "ISO" > "ISO_def"
+  "INJP" > "INJP_def"
+  "INJN" > "INJN_def"
+  "INJF" > "INJF_def"
+  "INJA" > "INJA_def"
+  "INJ" > "INJ_def"
+  "IND_SUC" > "IND_SUC_def"
+  "IND_0" > "IND_0_def"
+  "HAS_SIZE" > "HAS_SIZE_def"
+  "FNIL" > "FNIL_def"
+  "FINREC" > "FINREC_def"
+  "FCONS" > "FCONS_def"
+  "DECIMAL" > "DECIMAL_def"
+  "CROSS" > "CROSS_def"
+  "COUNTABLE" > "COUNTABLE_def"
+  "CONSTR" > "CONSTR_def"
+  "CASEWISE" > "CASEWISE_def"
+  "CARD" > "CARD_def"
+  "BOTTOM" > "BOTTOM_def"
+  "BIJ" > "BIJ_def"
+  "ASCII" > "ASCII_def"
+  ">_c" > ">_c_def"
+  ">=_c" > ">=_c_def"
+  "=_c" > "=_c_def"
+  "<_c" > "<_c_def"
+  "<=_c" > "<=_c_def"
+  "$" > "$_def"
+
+type_maps
+  "sum" > "Sum_Type.sum"
+  "recspace" > "HOLLight.hollight.recspace"
+  "real" > "HOLLight.hollight.real"
+  "prod" > "Product_Type.prod"
+  "option" > "Datatype.option"
+  "num" > "Nat.nat"
+  "nadd" > "HOLLight.hollight.nadd"
+  "list" > "List.list"
+  "int" > "HOLLight.hollight.int"
+  "ind" > "Nat.ind"
+  "hreal" > "HOLLight.hollight.hreal"
+  "fun" > "fun"
+  "finite_sum" > "HOLLight.hollight.finite_sum"
+  "finite_image" > "HOLLight.hollight.finite_image"
+  "char" > "HOLLight.hollight.char"
+  "cart" > "HOLLight.hollight.cart"
+  "bool" > "HOL.bool"
+  "N_3" > "HOLLight.hollight.N_3"
+  "N_2" > "HOLLight.hollight.N_2"
+  "N_1" > "Product_Type.unit"
+
+const_maps
+  "~" > "HOL.Not"
+  "vector" > "HOLLight.hollight.vector"
+  "treal_of_num" > "HOLLight.hollight.treal_of_num"
+  "treal_neg" > "HOLLight.hollight.treal_neg"
+  "treal_mul" > "HOLLight.hollight.treal_mul"
+  "treal_le" > "HOLLight.hollight.treal_le"
+  "treal_inv" > "HOLLight.hollight.treal_inv"
+  "treal_eq" > "HOLLight.hollight.treal_eq"
+  "treal_add" > "HOLLight.hollight.treal_add"
+  "tailadmissible" > "HOLLight.hollight.tailadmissible"
+  "support" > "HOLLight.hollight.support"
+  "superadmissible" > "HOLLight.hollight.superadmissible"
+  "sum" > "HOLLight.hollight.sum"
+  "sndcart" > "HOLLight.hollight.sndcart"
+  "set_of_list" > "List.set"
+  "rem" > "HOLLight.hollight.rem"
+  "real_sub" > "HOLLight.hollight.real_sub"
+  "real_sgn" > "HOLLight.hollight.real_sgn"
+  "real_pow" > "HOLLight.hollight.real_pow"
+  "real_of_num" > "HOLLight.hollight.real_of_num"
+  "real_neg" > "HOLLight.hollight.real_neg"
+  "real_mul" > "HOLLight.hollight.real_mul"
+  "real_mod" > "HOLLight.hollight.real_mod"
+  "real_min" > "HOLLight.hollight.real_min"
+  "real_max" > "HOLLight.hollight.real_max"
+  "real_lt" > "HOLLight.hollight.real_lt"
+  "real_le" > "HOLLight.hollight.real_le"
+  "real_inv" > "HOLLight.hollight.real_inv"
+  "real_gt" > "HOLLight.hollight.real_gt"
+  "real_ge" > "HOLLight.hollight.real_ge"
+  "real_div" > "HOLLight.hollight.real_div"
+  "real_add" > "HOLLight.hollight.real_add"
+  "real_abs" > "HOLLight.hollight.real_abs"
+  "pastecart" > "HOLLight.hollight.pastecart"
+  "pairwise" > "HOLLight.hollight.pairwise"
+  "one" > "Product_Type.Unity"
+  "o" > "Fun.comp"
+  "num_of_int" > "HOLLight.hollight.num_of_int"
+  "num_mod" > "HOLLight.hollight.num_mod"
+  "num_gcd" > "HOLLight.hollight.num_gcd"
+  "num_divides" > "HOLLight.hollight.num_divides"
+  "num_coprime" > "HOLLight.hollight.num_coprime"
+  "nsum" > "HOLLight.hollight.nsum"
+  "neutral" > "HOLLight.hollight.neutral"
+  "nadd_rinv" > "HOLLight.hollight.nadd_rinv"
+  "nadd_of_num" > "HOLLight.hollight.nadd_of_num"
+  "nadd_mul" > "HOLLight.hollight.nadd_mul"
+  "nadd_le" > "HOLLight.hollight.nadd_le"
+  "nadd_inv" > "HOLLight.hollight.nadd_inv"
+  "nadd_eq" > "HOLLight.hollight.nadd_eq"
+  "nadd_add" > "HOLLight.hollight.nadd_add"
+  "monoidal" > "HOLLight.hollight.monoidal"
+  "mk_pair" > "Product_Type.Pair_Rep"
+  "mk_num" > "Fun.id"
+  "minimal" > "HOLLight.hollight.minimal"
+  "list_EX" > "List.list_ex"
+  "list_ALL" > "List.list_all"
+  "lambda" > "HOLLight.hollight.lambda"
+  "iterate" > "HOLLight.hollight.iterate"
+  "is_nadd" > "HOLLight.hollight.is_nadd"
+  "integer" > "HOLLight.hollight.integer"
+  "int_sub" > "HOLLight.hollight.int_sub"
+  "int_sgn" > "HOLLight.hollight.int_sgn"
+  "int_pow" > "HOLLight.hollight.int_pow"
+  "int_of_num" > "HOLLight.hollight.int_of_num"
+  "int_neg" > "HOLLight.hollight.int_neg"
+  "int_mul" > "HOLLight.hollight.int_mul"
+  "int_mod" > "HOLLight.hollight.int_mod"
+  "int_min" > "HOLLight.hollight.int_min"
+  "int_max" > "HOLLight.hollight.int_max"
+  "int_lt" > "HOLLight.hollight.int_lt"
+  "int_le" > "HOLLight.hollight.int_le"
+  "int_gt" > "HOLLight.hollight.int_gt"
+  "int_ge" > "HOLLight.hollight.int_ge"
+  "int_gcd" > "HOLLight.hollight.int_gcd"
+  "int_divides" > "HOLLight.hollight.int_divides"
+  "int_coprime" > "HOLLight.hollight.int_coprime"
+  "int_add" > "HOLLight.hollight.int_add"
+  "int_abs" > "HOLLight.hollight.int_abs"
+  "hreal_of_num" > "HOLLight.hollight.hreal_of_num"
+  "hreal_mul" > "HOLLight.hollight.hreal_mul"
+  "hreal_le" > "HOLLight.hollight.hreal_le"
+  "hreal_inv" > "HOLLight.hollight.hreal_inv"
+  "hreal_add" > "HOLLight.hollight.hreal_add"
+  "fstcart" > "HOLLight.hollight.fstcart"
+  "eqeq" > "HOLLight.hollight.eqeq"
+  "div" > "HOLLight.hollight.div"
+  "dist" > "HOLLight.hollight.dist"
+  "dimindex" > "HOLLight.hollight.dimindex"
+  "admissible" > "HOLLight.hollight.admissible"
+  "_UNGUARDED_PATTERN" > "HOLLight.hollight._UNGUARDED_PATTERN"
+  "_SEQPATTERN" > "HOLLight.hollight._SEQPATTERN"
+  "_MATCH" > "HOLLight.hollight._MATCH"
+  "_GUARDED_PATTERN" > "HOLLight.hollight._GUARDED_PATTERN"
+  "_FUNCTION" > "HOLLight.hollight._FUNCTION"
+  "_FALSITY_" > "HOLLight.hollight._FALSITY_"
+  "_11937" > "HOLLight.hollight._11937"
+  "_0" > "Groups.zero_class.zero" :: "nat"
+  "\\/" > "HOL.disj"
+  "ZRECSPACE" > "HOLLight.hollight.ZRECSPACE"
+  "ZIP" > "List.zip"
+  "ZCONSTR" > "HOLLight.hollight.ZCONSTR"
+  "ZBOT" > "HOLLight.hollight.ZBOT"
+  "WF" > "Wellfounded.wfP"
+  "UNIV" > "Orderings.top_class.top" :: "'a => bool"
+  "UNIONS" > "Complete_Lattices.Sup_class.Sup" :: "(('a => bool) => bool) => 'a => bool"
+  "UNION" > "Lattices.sup_class.sup" :: "('a => bool) => ('a => bool) => 'a => bool"
+  "UNCURRY" > "HOLLight.hollight.UNCURRY"
+  "TL" > "List.tl"
+  "T" > "HOL.True"
+  "SURJ" > "HOLLight.hollight.SURJ"
+  "SUC" > "Nat.Suc"
+  "SUBSET" > "Orderings.ord_class.less_eq" :: "('a => bool) => ('a => bool) => bool"
+  "SOME" > "Datatype.Some"
+  "SND" > "Product_Type.snd"
+  "SING" > "HOLLight.hollight.SING"
+  "SETSPEC" > "HOLLightCompat.SETSPEC"
+  "REVERSE" > "List.rev"
+  "REST" > "HOLLight.hollight.REST"
+  "REPLICATE" > "List.replicate"
+  "PSUBSET" > "Orderings.ord_class.less" :: "('a => bool) => ('a => bool) => bool"
+  "PRE" > "HOLLightCompat.Pred"
+  "PASSOC" > "HOLLight.hollight.PASSOC"
+  "PAIRWISE" > "HOLLight.hollight.PAIRWISE"
+  "OUTR" > "HOLLightCompat.OUTR"
+  "OUTL" > "HOLLightCompat.OUTL"
+  "ONTO" > "Fun.surj"
+  "ONE_ONE" > "Fun.inj"
+  "ODD" > "HOLLightCompat.ODD"
+  "NUM_REP" > "HOLLight.hollight.NUM_REP"
+  "NUMSUM" > "HOLLight.hollight.NUMSUM"
+  "NUMSND" > "HOLLight.hollight.NUMSND"
+  "NUMRIGHT" > "HOLLight.hollight.NUMRIGHT"
+  "NUMPAIR" > "HOLLight.hollight.NUMPAIR"
+  "NUMLEFT" > "HOLLight.hollight.NUMLEFT"
+  "NUMFST" > "HOLLight.hollight.NUMFST"
+  "NUMERAL" > "HOLLightCompat.NUMERAL"
+  "NULL" > "List.null"
+  "NONE" > "Datatype.None"
+  "NIL" > "List.list.Nil"
+  "MOD" > "Divides.div_class.mod" :: "nat => nat => nat"
+  "MIN" > "Orderings.ord_class.min" :: "nat => nat => nat"
+  "MEM" > "HOLLightList.list_mem"
+  "MEASURE" > "HOLLightCompat.MEASURE"
+  "MAX" > "Orderings.ord_class.max" :: "nat => nat => nat"
+  "MAP2" > "HOLLightList.map2"
+  "MAP" > "List.map"
+  "LET_END" > "HOLLight.hollight.LET_END"
+  "LET" > "HOLLightCompat.LET"
+  "LENGTH" > "List.length"
+  "LAST" > "List.last"
+  "ITSET" > "HOLLight.hollight.ITSET"
+  "ITLIST2" > "HOLLightList.fold2"
+  "ITLIST" > "List.foldr"
+  "ISO" > "HOLLight.hollight.ISO"
+  "INTERS" > "Complete_Lattices.Inf_class.Inf" :: "(('a => bool) => bool) => 'a => bool"
+  "INTER" > "Lattices.inf_class.inf" :: "('a => bool) => ('a => bool) => 'a => bool"
+  "INSERT" > "Set.insert"
+  "INR" > "Sum_Type.Inr"
+  "INL" > "Sum_Type.Inl"
+  "INJP" > "HOLLight.hollight.INJP"
+  "INJN" > "HOLLight.hollight.INJN"
+  "INJF" > "HOLLight.hollight.INJF"
+  "INJA" > "HOLLight.hollight.INJA"
+  "INJ" > "HOLLight.hollight.INJ"
+  "INFINITE" > "HOLLightCompat.INFINITE"
+  "IND_SUC" > "HOLLight.hollight.IND_SUC"
+  "IND_0" > "HOLLight.hollight.IND_0"
+  "IN" > "Set.member"
+  "IMAGE" > "Set.image"
+  "I" > "Fun.id"
+  "HD" > "List.hd"
+  "HAS_SIZE" > "HOLLight.hollight.HAS_SIZE"
+  "GSPEC" > "Set.Collect"
+  "GEQ" > "HOL.eq"
+  "GABS" > "Hilbert_Choice.Eps"
+  "FST" > "Product_Type.fst"
+  "FNIL" > "HOLLight.hollight.FNIL"
+  "FINREC" > "HOLLight.hollight.FINREC"
+  "FINITE" > "Finite_Set.finite"
+  "FILTER" > "List.filter"
+  "FCONS" > "HOLLight.hollight.FCONS"
+  "FACT" > "Fact.fact_class.fact" :: "nat => nat"
+  "F" > "HOL.False"
+  "EXP" > "Power.power_class.power" :: "nat => nat => nat"
+  "EVEN" > "Parity.even_odd_class.even" :: "nat => bool"
+  "EMPTY" > "Orderings.bot_class.bot" :: "'a => bool"
+  "EL" > "HOLLightList.list_el"
+  "DIV" > "Divides.div_class.div" :: "nat => nat => nat"
+  "DISJOINT" > "HOLLightCompat.DISJOINT"
+  "DIFF" > "Groups.minus_class.minus" :: "('a => bool) => ('a => bool) => 'a => bool"
+  "DELETE" > "HOLLightCompat.DELETE"
+  "DECIMAL" > "HOLLight.hollight.DECIMAL"
+  "CURRY" > "Product_Type.curry"
+  "CROSS" > "HOLLight.hollight.CROSS"
+  "COUNTABLE" > "HOLLight.hollight.COUNTABLE"
+  "CONSTR" > "HOLLight.hollight.CONSTR"
+  "CONS" > "List.list.Cons"
+  "COND" > "HOL.If"
+  "CHOICE" > "Hilbert_Choice.Eps"
+  "CASEWISE" > "HOLLight.hollight.CASEWISE"
+  "CARD" > "HOLLight.hollight.CARD"
+  "BUTLAST" > "List.butlast"
+  "BOTTOM" > "HOLLight.hollight.BOTTOM"
+  "BIT1" > "HOLLightCompat.NUMERAL_BIT1"
+  "BIT0" > "HOLLightCompat.NUMERAL_BIT0"
+  "BIJ" > "HOLLight.hollight.BIJ"
+  "ASCII" > "HOLLight.hollight.ASCII"
+  "APPEND" > "List.append"
+  "ALL2" > "List.list_all2"
+  "@" > "Hilbert_Choice.Eps"
+  "?!" > "HOL.Ex1"
+  "?" > "HOL.Ex"
+  ">_c" > "HOLLight.hollight.>_c"
+  ">=_c" > "HOLLight.hollight.>=_c"
+  ">=" > "Orderings.ord_class.greater_eq" :: "nat => nat => bool"
+  ">" > "Orderings.ord_class.greater" :: "nat => nat => bool"
+  "=_c" > "HOLLight.hollight.=_c"
+  "==>" > "HOL.implies"
+  "=" > "HOL.eq"
+  "<_c" > "HOLLight.hollight.<_c"
+  "<=_c" > "HOLLight.hollight.<=_c"
+  "<=" > "Orderings.ord_class.less_eq" :: "nat => nat => bool"
+  "<" > "Orderings.ord_class.less" :: "nat => nat => bool"
+  "/\\" > "HOL.conj"
+  ".." > "HOLLightCompat.dotdot"
+  "-" > "Groups.minus_class.minus" :: "nat => nat => nat"
+  "," > "Product_Type.Pair"
+  "+" > "Groups.plus_class.plus" :: "nat => nat => nat"
+  "*" > "Groups.times_class.times" :: "nat => nat => nat"
+  "$" > "HOLLight.hollight.$"
+  "!" > "HOL.All"
+
+const_renames
+  "EX" > "list_EX"
+  "ALL" > "list_ALL"
+  "==" > "eqeq"
+
+thm_maps
+  "vector_def" > "HOLLight.hollight.vector_def"
+  "treal_of_num_def" > "HOLLight.hollight.treal_of_num_def"
+  "treal_neg_def" > "HOLLight.hollight.treal_neg_def"
+  "treal_mul_def" > "HOLLight.hollight.treal_mul_def"
+  "treal_le_def" > "HOLLight.hollight.treal_le_def"
+  "treal_inv_def" > "HOLLight.hollight.treal_inv_def"
+  "treal_eq_def" > "HOLLight.hollight.treal_eq_def"
+  "treal_add_def" > "HOLLight.hollight.treal_add_def"
+  "th_cond" > "HOLLight.hollight.th_cond"
+  "th" > "HOL.eta_contract_eq"
+  "tailadmissible_def" > "HOLLight.hollight.tailadmissible_def"
+  "support_def" > "HOLLight.hollight.support_def"
+  "superadmissible_def" > "HOLLight.hollight.superadmissible_def"
+  "sum_def" > "HOLLight.hollight.sum_def"
+  "string_INFINITE" > "List.infinite_UNIV_listI"
+  "sth" > "HOLLight.hollight.sth"
+  "sndcart_def" > "HOLLight.hollight.sndcart_def"
+  "right_th" > "HOLLight.hollight.right_th"
+  "rem_def" > "HOLLight.hollight.rem_def"
+  "real_sub_def" > "HOLLight.hollight.real_sub_def"
+  "real_sgn_def" > "HOLLight.hollight.real_sgn_def"
+  "real_pow_def" > "HOLLight.hollight.real_pow_def"
+  "real_of_num_def" > "HOLLight.hollight.real_of_num_def"
+  "real_neg_def" > "HOLLight.hollight.real_neg_def"
+  "real_mul_def" > "HOLLight.hollight.real_mul_def"
+  "real_mod_def" > "HOLLight.hollight.real_mod_def"
+  "real_min_def" > "HOLLight.hollight.real_min_def"
+  "real_max_def" > "HOLLight.hollight.real_max_def"
+  "real_lt_def" > "HOLLight.hollight.real_lt_def"
+  "real_le_def" > "HOLLight.hollight.real_le_def"
+  "real_inv_def" > "HOLLight.hollight.real_inv_def"
+  "real_gt_def" > "HOLLight.hollight.real_gt_def"
+  "real_ge_def" > "HOLLight.hollight.real_ge_def"
+  "real_div_def" > "HOLLight.hollight.real_div_def"
+  "real_add_def" > "HOLLight.hollight.real_add_def"
+  "real_abs_def" > "HOLLight.hollight.real_abs_def"
+  "real_INFINITE" > "HOLLight.hollight.real_INFINITE"
+  "pastecart_def" > "HOLLight.hollight.pastecart_def"
+  "pairwise_def" > "HOLLight.hollight.pairwise_def"
+  "pair_RECURSION" > "HOLLight.hollight.pair_RECURSION"
+  "pair_INDUCT" > "Product_Type.prod.induct"
+  "one_axiom" > "HOLLight.hollight.one_axiom"
+  "one_RECURSION" > "HOLLight.hollight.one_RECURSION"
+  "one_INDUCT" > "Product_Type.unit.induct"
+  "one_Axiom" > "HOLLight.hollight.one_Axiom"
+  "one" > "HOLLightCompat.one"
+  "o_THM" > "Fun.comp_def"
+  "o_ASSOC" > "HOLLight.hollight.o_ASSOC"
+  "num_of_int_def" > "HOLLight.hollight.num_of_int_def"
+  "num_mod_def" > "HOLLight.hollight.num_mod_def"
+  "num_gcd_def" > "HOLLight.hollight.num_gcd_def"
+  "num_divides_def" > "HOLLight.hollight.num_divides_def"
+  "num_coprime_def" > "HOLLight.hollight.num_coprime_def"
+  "num_congruent" > "HOLLight.hollight.num_congruent"
+  "num_WOP" > "HOLLight.hollight.num_WOP"
+  "num_WF" > "Nat.nat_less_induct"
+  "num_RECURSION_STD" > "HOLLight.hollight.num_RECURSION_STD"
+  "num_MAX" > "HOLLight.hollight.num_MAX"
+  "num_INFINITE" > "Finite_Set.infinite_UNIV_char_0"
+  "num_INDUCTION" > "Fact.fact_nat.induct"
+  "num_FINITE_AVOID" > "HOLLight.hollight.num_FINITE_AVOID"
+  "num_FINITE" > "HOLLight.hollight.num_FINITE"
+  "num_CASES" > "Nat.nat.nchotomy"
+  "num_Axiom" > "HOLLightCompat.num_Axiom"
+  "nsum_def" > "HOLLight.hollight.nsum_def"
+  "neutral_def" > "HOLLight.hollight.neutral_def"
+  "nadd_rinv_def" > "HOLLight.hollight.nadd_rinv_def"
+  "nadd_of_num_def" > "HOLLight.hollight.nadd_of_num_def"
+  "nadd_mul_def" > "HOLLight.hollight.nadd_mul_def"
+  "nadd_le_def" > "HOLLight.hollight.nadd_le_def"
+  "nadd_inv_def" > "HOLLight.hollight.nadd_inv_def"
+  "nadd_eq_def" > "HOLLight.hollight.nadd_eq_def"
+  "nadd_add_def" > "HOLLight.hollight.nadd_add_def"
+  "monoidal_def" > "HOLLight.hollight.monoidal_def"
+  "minimal_def" > "HOLLight.hollight.minimal_def"
+  "list_INDUCT" > "List.list.induct"
+  "list_CASES" > "List.list.nchotomy"
+  "lambda_def" > "HOLLight.hollight.lambda_def"
+  "iterate_def" > "HOLLight.hollight.iterate_def"
+  "is_nadd_def" > "HOLLight.hollight.is_nadd_def"
+  "is_nadd_0" > "HOLLight.hollight.is_nadd_0"
+  "is_int" > "HOLLight.hollight.is_int"
+  "integer_def" > "HOLLight.hollight.integer_def"
+  "int_sub_th" > "HOLLight.hollight.int_sub_th"
+  "int_sub_def" > "HOLLight.hollight.int_sub_def"
+  "int_sgn_th" > "HOLLight.hollight.int_sgn_th"
+  "int_sgn_def" > "HOLLight.hollight.int_sgn_def"
+  "int_pow_th" > "HOLLight.hollight.int_pow_th"
+  "int_pow_def" > "HOLLight.hollight.int_pow_def"
+  "int_of_num_th" > "HOLLight.hollight.int_of_num_th"
+  "int_of_num_def" > "HOLLight.hollight.int_of_num_def"
+  "int_neg_th" > "HOLLight.hollight.int_neg_th"
+  "int_neg_def" > "HOLLight.hollight.int_neg_def"
+  "int_mul_th" > "HOLLight.hollight.int_mul_th"
+  "int_mul_def" > "HOLLight.hollight.int_mul_def"
+  "int_mod_def" > "HOLLight.hollight.int_mod_def"
+  "int_min_th" > "HOLLight.hollight.int_min_th"
+  "int_min_def" > "HOLLight.hollight.int_min_def"
+  "int_max_th" > "HOLLight.hollight.int_max_th"
+  "int_max_def" > "HOLLight.hollight.int_max_def"
+  "int_lt_def" > "HOLLight.hollight.int_lt_def"
+  "int_le_def" > "HOLLight.hollight.int_le_def"
+  "int_gt_def" > "HOLLight.hollight.int_gt_def"
+  "int_ge_def" > "HOLLight.hollight.int_ge_def"
+  "int_gcd_def" > "HOLLight.hollight.int_gcd_def"
+  "int_eq" > "HOLLight.hollight.int.real_of_int_inject"
+  "int_divides_def" > "HOLLight.hollight.int_divides_def"
+  "int_coprime_def" > "HOLLight.hollight.int_coprime_def"
+  "int_congruent" > "HOLLight.hollight.int_congruent"
+  "int_add_th" > "HOLLight.hollight.int_add_th"
+  "int_add_def" > "HOLLight.hollight.int_add_def"
+  "int_abs_th" > "HOLLight.hollight.int_abs_th"
+  "int_abs_def" > "HOLLight.hollight.int_abs_def"
+  "hreal_of_num_def" > "HOLLight.hollight.hreal_of_num_def"
+  "hreal_mul_def" > "HOLLight.hollight.hreal_mul_def"
+  "hreal_le_def" > "HOLLight.hollight.hreal_le_def"
+  "hreal_inv_def" > "HOLLight.hollight.hreal_inv_def"
+  "hreal_add_def" > "HOLLight.hollight.hreal_add_def"
+  "fstcart_def" > "HOLLight.hollight.fstcart_def"
+  "eqeq_def" > "HOLLight.hollight.eqeq_def"
+  "elemma0" > "HOLLight.hollight.elemma0"
+  "div_def" > "HOLLight.hollight.div_def"
+  "dist_def" > "HOLLight.hollight.dist_def"
+  "dimindex_def" > "HOLLight.hollight.dimindex_def"
+  "dest_int_rep" > "HOLLight.hollight.dest_int_rep"
+  "cth" > "HOLLight.hollight.cth"
+  "bool_RECURSION" > "HOLLight.hollight.bool_RECURSION"
+  "bool_INDUCT" > "Product_Type.bool.induct"
+  "ax__3" > "HOL4Setup.INFINITY_AX"
+  "ax__2" > "Hilbert_Choice.someI"
+  "ax__1" > "HOL.eta_contract_eq"
+  "admissible_def" > "HOLLight.hollight.admissible_def"
+  "_UNGUARDED_PATTERN_def" > "HOLLight.hollight._UNGUARDED_PATTERN_def"
+  "_SEQPATTERN_def" > "HOLLight.hollight._SEQPATTERN_def"
+  "_MATCH_def" > "HOLLight.hollight._MATCH_def"
+  "_GUARDED_PATTERN_def" > "HOLLight.hollight._GUARDED_PATTERN_def"
+  "_FUNCTION_def" > "HOLLight.hollight._FUNCTION_def"
+  "_FALSITY__def" > "HOLLight.hollight._FALSITY__def"
+  "_11937_def" > "HOLLight.hollight._11937_def"
+  "ZRECSPACE_def" > "HOLLight.hollight.ZRECSPACE_def"
+  "ZIP" > "HOLLightList.ZIP"
+  "ZCONSTR_def" > "HOLLight.hollight.ZCONSTR_def"
+  "ZCONSTR_ZBOT" > "HOLLight.hollight.ZCONSTR_ZBOT"
+  "ZBOT_def" > "HOLLight.hollight.ZBOT_def"
+  "WLOG_LT" > "HOLLight.hollight.WLOG_LT"
+  "WLOG_LE" > "HOLLight.hollight.WLOG_LE"
+  "WF_num" > "HOLLight.hollight.WF_num"
+  "WF_UREC_WF" > "HOLLight.hollight.WF_UREC_WF"
+  "WF_UREC" > "HOLLight.hollight.WF_UREC"
+  "WF_SUBSET" > "HOLLight.hollight.WF_SUBSET"
+  "WF_REFL" > "HOLLight.hollight.WF_REFL"
+  "WF_REC_num" > "HOLLight.hollight.WF_REC_num"
+  "WF_REC_WF" > "HOLLight.hollight.WF_REC_WF"
+  "WF_REC_TAIL_GENERAL" > "HOLLight.hollight.WF_REC_TAIL_GENERAL"
+  "WF_REC_TAIL" > "HOLLight.hollight.WF_REC_TAIL"
+  "WF_REC_INVARIANT" > "HOLLight.hollight.WF_REC_INVARIANT"
+  "WF_REC" > "HOLLight.hollight.WF_REC"
+  "WF_POINTWISE" > "HOLLight.hollight.WF_POINTWISE"
+  "WF_MEASURE_GEN" > "HOLLight.hollight.WF_MEASURE_GEN"
+  "WF_MEASURE" > "HOLLight.hollight.WF_MEASURE"
+  "WF_LEX_DEPENDENT" > "HOLLight.hollight.WF_LEX_DEPENDENT"
+  "WF_LEX" > "HOLLight.hollight.WF_LEX"
+  "WF_INT_MEASURE_2" > "HOLLight.hollight.WF_INT_MEASURE_2"
+  "WF_INT_MEASURE" > "HOLLight.hollight.WF_INT_MEASURE"
+  "WF_IND" > "HOLLight.hollight.WF_IND"
+  "WF_FINITE" > "HOLLight.hollight.WF_FINITE"
+  "WF_FALSE" > "Wellfounded.wfP_empty"
+  "WF_EREC" > "HOLLight.hollight.WF_EREC"
+  "WF_EQ" > "HOLLight.hollight.WF_EQ"
+  "WF_DCHAIN" > "HOLLight.hollight.WF_DCHAIN"
+  "UNWIND_THM2" > "HOL.simp_thms_39"
+  "UNWIND_THM1" > "HOL.simp_thms_40"
+  "UNIV_SUBSET" > "Orderings.top_class.top_unique"
+  "UNIV_NOT_EMPTY" > "Set.UNIV_not_empty"
+  "UNIQUE_SKOLEM_THM" > "HOL.choice_eq"
+  "UNIQUE_SKOLEM_ALT" > "HOLLight.hollight.UNIQUE_SKOLEM_ALT"
+  "UNION_UNIV" > "HOLLight.hollight.UNION_UNIV"
+  "UNION_SUBSET" > "Lattices.semilattice_sup_class.le_sup_iff"
+  "UNION_OVER_INTER" > "Lattices.distrib_lattice_class.distrib_3"
+  "UNION_IDEMPOT" > "Big_Operators.lattice_class.Sup_fin.idem"
+  "UNION_EMPTY" > "HOLLight.hollight.UNION_EMPTY"
+  "UNION_COMM" > "Lattices.lattice_class.inf_sup_aci_5"
+  "UNION_ASSOC" > "Lattices.lattice_class.inf_sup_aci_6"
+  "UNION_ACI" > "HOLLight.hollight.UNION_ACI"
+  "UNIONS_UNION" > "Complete_Lattices.Union_Un_distrib"
+  "UNIONS_SUBSET" > "HOLLight.hollight.UNIONS_SUBSET"
+  "UNIONS_INTERS" > "HOLLight.hollight.UNIONS_INTERS"
+  "UNIONS_INSERT" > "Complete_Lattices.Union_insert"
+  "UNIONS_IMAGE" > "HOLLight.hollight.UNIONS_IMAGE"
+  "UNIONS_GSPEC" > "HOLLight.hollight.UNIONS_GSPEC"
+  "UNIONS_2" > "Complete_Lattices.Un_eq_Union"
+  "UNIONS_1" > "Complete_Lattices.complete_lattice_class.Sup_singleton"
+  "UNIONS_0" > "Complete_Lattices.Union_empty"
+  "UNCURRY_def" > "HOLLight.hollight.UNCURRY_def"
+  "TYDEF_recspace" > "HOLLight.hollight.TYDEF_recspace"
+  "TYDEF_real" > "HOLLight.hollight.TYDEF_real"
+  "TYDEF_nadd" > "HOLLight.hollight.TYDEF_nadd"
+  "TYDEF_int" > "HOLLight.hollight.TYDEF_int"
+  "TYDEF_hreal" > "HOLLight.hollight.TYDEF_hreal"
+  "TYDEF_finite_sum" > "HOLLight.hollight.TYDEF_finite_sum"
+  "TYDEF_finite_image" > "HOLLight.hollight.TYDEF_finite_image"
+  "TYDEF_char" > "HOLLight.hollight.TYDEF_char"
+  "TYDEF_cart" > "HOLLight.hollight.TYDEF_cart"
+  "TYDEF_3" > "HOLLight.hollight.TYDEF_3"
+  "TYDEF_2" > "HOLLight.hollight.TYDEF_2"
+  "TWO" > "HOLLight.hollight.TWO"
+  "TRIV_OR_FORALL_THM" > "HOLLight.hollight.TRIV_OR_FORALL_THM"
+  "TRIV_FORALL_OR_THM" > "HOLLight.hollight.TRIV_FORALL_OR_THM"
+  "TRIV_FORALL_IMP_THM" > "HOLLight.hollight.TRIV_FORALL_IMP_THM"
+  "TRIV_EXISTS_IMP_THM" > "HOLLight.hollight.TRIV_EXISTS_IMP_THM"
+  "TRIV_EXISTS_AND_THM" > "HOLLight.hollight.TRIV_EXISTS_AND_THM"
+  "TRIV_AND_EXISTS_THM" > "HOLLight.hollight.TRIV_AND_EXISTS_THM"
+  "TREAL_OF_NUM_WELLDEF" > "HOLLight.hollight.TREAL_OF_NUM_WELLDEF"
+  "TREAL_OF_NUM_MUL" > "HOLLight.hollight.TREAL_OF_NUM_MUL"
+  "TREAL_OF_NUM_LE" > "HOLLight.hollight.TREAL_OF_NUM_LE"
+  "TREAL_OF_NUM_EQ" > "HOLLight.hollight.TREAL_OF_NUM_EQ"
+  "TREAL_OF_NUM_ADD" > "HOLLight.hollight.TREAL_OF_NUM_ADD"
+  "TREAL_NEG_WELLDEF" > "HOLLight.hollight.TREAL_NEG_WELLDEF"
+  "TREAL_MUL_WELLDEFR" > "HOLLight.hollight.TREAL_MUL_WELLDEFR"
+  "TREAL_MUL_WELLDEF" > "HOLLight.hollight.TREAL_MUL_WELLDEF"
+  "TREAL_MUL_SYM_EQ" > "HOLLight.hollight.TREAL_MUL_SYM_EQ"
+  "TREAL_MUL_SYM" > "HOLLight.hollight.TREAL_MUL_SYM"
+  "TREAL_MUL_LINV" > "HOLLight.hollight.TREAL_MUL_LINV"
+  "TREAL_MUL_LID" > "HOLLight.hollight.TREAL_MUL_LID"
+  "TREAL_MUL_ASSOC" > "HOLLight.hollight.TREAL_MUL_ASSOC"
+  "TREAL_LE_WELLDEF" > "HOLLight.hollight.TREAL_LE_WELLDEF"
+  "TREAL_LE_TRANS" > "HOLLight.hollight.TREAL_LE_TRANS"
+  "TREAL_LE_TOTAL" > "HOLLight.hollight.TREAL_LE_TOTAL"
+  "TREAL_LE_REFL" > "HOLLight.hollight.TREAL_LE_REFL"
+  "TREAL_LE_MUL" > "HOLLight.hollight.TREAL_LE_MUL"
+  "TREAL_LE_LADD_IMP" > "HOLLight.hollight.TREAL_LE_LADD_IMP"
+  "TREAL_LE_ANTISYM" > "HOLLight.hollight.TREAL_LE_ANTISYM"
+  "TREAL_INV_WELLDEF" > "HOLLight.hollight.TREAL_INV_WELLDEF"
+  "TREAL_INV_0" > "HOLLight.hollight.TREAL_INV_0"
+  "TREAL_EQ_TRANS" > "HOLLight.hollight.TREAL_EQ_TRANS"
+  "TREAL_EQ_SYM" > "HOLLight.hollight.TREAL_EQ_SYM"
+  "TREAL_EQ_REFL" > "HOLLight.hollight.TREAL_EQ_REFL"
+  "TREAL_EQ_IMP_LE" > "HOLLight.hollight.TREAL_EQ_IMP_LE"
+  "TREAL_EQ_AP" > "HOLLight.hollight.TREAL_EQ_AP"
+  "TREAL_ADD_WELLDEFR" > "HOLLight.hollight.TREAL_ADD_WELLDEFR"
+  "TREAL_ADD_WELLDEF" > "HOLLight.hollight.TREAL_ADD_WELLDEF"
+  "TREAL_ADD_SYM_EQ" > "HOLLight.hollight.TREAL_ADD_SYM_EQ"
+  "TREAL_ADD_SYM" > "HOLLight.hollight.TREAL_ADD_SYM"
+  "TREAL_ADD_LINV" > "HOLLight.hollight.TREAL_ADD_LINV"
+  "TREAL_ADD_LID" > "HOLLight.hollight.TREAL_ADD_LID"
+  "TREAL_ADD_LDISTRIB" > "HOLLight.hollight.TREAL_ADD_LDISTRIB"
+  "TREAL_ADD_ASSOC" > "HOLLight.hollight.TREAL_ADD_ASSOC"
+  "TRANSITIVE_STEPWISE_LT_EQ" > "HOLLight.hollight.TRANSITIVE_STEPWISE_LT_EQ"
+  "TRANSITIVE_STEPWISE_LT" > "HOLLight.hollight.TRANSITIVE_STEPWISE_LT"
+  "TRANSITIVE_STEPWISE_LE_EQ" > "HOLLight.hollight.TRANSITIVE_STEPWISE_LE_EQ"
+  "TRANSITIVE_STEPWISE_LE" > "HOLLight.hollight.TRANSITIVE_STEPWISE_LE"
+  "TOPOLOGICAL_SORT" > "HOLLight.hollight.TOPOLOGICAL_SORT"
+  "SWAP_FORALL_THM" > "HOL.all_comm"
+  "SWAP_EXISTS_THM" > "HOL.ex_comm"
+  "SURJ_def" > "HOLLight.hollight.SURJ_def"
+  "SURJECTIVE_RIGHT_INVERSE" > "HOLLight.hollight.SURJECTIVE_RIGHT_INVERSE"
+  "SURJECTIVE_ON_RIGHT_INVERSE" > "HOLLight.hollight.SURJECTIVE_ON_RIGHT_INVERSE"
+  "SURJECTIVE_ON_IMAGE" > "HOLLight.hollight.SURJECTIVE_ON_IMAGE"
+  "SURJECTIVE_MAP" > "HOLLightList.SURJECTIVE_MAP"
+  "SURJECTIVE_IMAGE_THM" > "HOLLight.hollight.SURJECTIVE_IMAGE_THM"
+  "SURJECTIVE_IMAGE_EQ" > "HOLLight.hollight.SURJECTIVE_IMAGE_EQ"
+  "SURJECTIVE_IMAGE" > "HOLLight.hollight.SURJECTIVE_IMAGE"
+  "SURJECTIVE_IFF_INJECTIVE_GEN" > "HOLLight.hollight.SURJECTIVE_IFF_INJECTIVE_GEN"
+  "SURJECTIVE_IFF_INJECTIVE" > "HOLLight.hollight.SURJECTIVE_IFF_INJECTIVE"
+  "SURJECTIVE_FORALL_THM" > "HOLLight.hollight.SURJECTIVE_FORALL_THM"
+  "SURJECTIVE_EXISTS_THM" > "HOLLight.hollight.SURJECTIVE_EXISTS_THM"
+  "SUPPORT_SUPPORT" > "HOLLight.hollight.SUPPORT_SUPPORT"
+  "SUPPORT_SUBSET" > "HOLLight.hollight.SUPPORT_SUBSET"
+  "SUPPORT_EMPTY" > "HOLLight.hollight.SUPPORT_EMPTY"
+  "SUPPORT_DELTA" > "HOLLight.hollight.SUPPORT_DELTA"
+  "SUPPORT_CLAUSES" > "HOLLight.hollight.SUPPORT_CLAUSES"
+  "SUPERADMISSIBLE_TAIL" > "HOLLight.hollight.SUPERADMISSIBLE_TAIL"
+  "SUPERADMISSIBLE_T" > "HOLLight.hollight.SUPERADMISSIBLE_T"
+  "SUPERADMISSIBLE_MATCH_UNGUARDED_PATTERN" > "HOLLight.hollight.SUPERADMISSIBLE_MATCH_UNGUARDED_PATTERN"
+  "SUPERADMISSIBLE_MATCH_SEQPATTERN" > "HOLLight.hollight.SUPERADMISSIBLE_MATCH_SEQPATTERN"
+  "SUPERADMISSIBLE_MATCH_GUARDED_PATTERN" > "HOLLight.hollight.SUPERADMISSIBLE_MATCH_GUARDED_PATTERN"
+  "SUPERADMISSIBLE_CONST" > "HOLLight.hollight.SUPERADMISSIBLE_CONST"
+  "SUPERADMISSIBLE_COND" > "HOLLight.hollight.SUPERADMISSIBLE_COND"
+  "SUM_ZERO_EXISTS" > "HOLLight.hollight.SUM_ZERO_EXISTS"
+  "SUM_UNION_RZERO" > "HOLLight.hollight.SUM_UNION_RZERO"
+  "SUM_UNION_NONZERO" > "HOLLight.hollight.SUM_UNION_NONZERO"
+  "SUM_UNION_LZERO" > "HOLLight.hollight.SUM_UNION_LZERO"
+  "SUM_UNION_EQ" > "HOLLight.hollight.SUM_UNION_EQ"
+  "SUM_UNIONS_NONZERO" > "HOLLight.hollight.SUM_UNIONS_NONZERO"
+  "SUM_UNION" > "HOLLight.hollight.SUM_UNION"
+  "SUM_TRIV_NUMSEG" > "HOLLight.hollight.SUM_TRIV_NUMSEG"
+  "SUM_SWAP_NUMSEG" > "HOLLight.hollight.SUM_SWAP_NUMSEG"
+  "SUM_SWAP" > "HOLLight.hollight.SUM_SWAP"
+  "SUM_SUPPORT" > "HOLLight.hollight.SUM_SUPPORT"
+  "SUM_SUPERSET" > "HOLLight.hollight.SUM_SUPERSET"
+  "SUM_SUM_RESTRICT" > "HOLLight.hollight.SUM_SUM_RESTRICT"
+  "SUM_SUM_PRODUCT" > "HOLLight.hollight.SUM_SUM_PRODUCT"
+  "SUM_SUB_NUMSEG" > "HOLLight.hollight.SUM_SUB_NUMSEG"
+  "SUM_SUBSET_SIMPLE" > "HOLLight.hollight.SUM_SUBSET_SIMPLE"
+  "SUM_SUBSET" > "HOLLight.hollight.SUM_SUBSET"
+  "SUM_SUB" > "HOLLight.hollight.SUM_SUB"
+  "SUM_SING_NUMSEG" > "HOLLight.hollight.SUM_SING_NUMSEG"
+  "SUM_SING" > "HOLLight.hollight.SUM_SING"
+  "SUM_RMUL" > "HOLLight.hollight.SUM_RMUL"
+  "SUM_RESTRICT_SET" > "HOLLight.hollight.SUM_RESTRICT_SET"
+  "SUM_RESTRICT" > "HOLLight.hollight.SUM_RESTRICT"
+  "SUM_POS_LE_NUMSEG" > "HOLLight.hollight.SUM_POS_LE_NUMSEG"
+  "SUM_POS_LE" > "HOLLight.hollight.SUM_POS_LE"
+  "SUM_POS_EQ_0_NUMSEG" > "HOLLight.hollight.SUM_POS_EQ_0_NUMSEG"
+  "SUM_POS_EQ_0" > "HOLLight.hollight.SUM_POS_EQ_0"
+  "SUM_POS_BOUND" > "HOLLight.hollight.SUM_POS_BOUND"
+  "SUM_PARTIAL_SUC" > "HOLLight.hollight.SUM_PARTIAL_SUC"
+  "SUM_PARTIAL_PRE" > "HOLLight.hollight.SUM_PARTIAL_PRE"
+  "SUM_PAIR" > "HOLLight.hollight.SUM_PAIR"
+  "SUM_OFFSET_0" > "HOLLight.hollight.SUM_OFFSET_0"
+  "SUM_OFFSET" > "HOLLight.hollight.SUM_OFFSET"
+  "SUM_NEG" > "HOLLight.hollight.SUM_NEG"
+  "SUM_MULTICOUNT_GEN" > "HOLLight.hollight.SUM_MULTICOUNT_GEN"
+  "SUM_MULTICOUNT" > "HOLLight.hollight.SUM_MULTICOUNT"
+  "SUM_LT_ALL" > "HOLLight.hollight.SUM_LT_ALL"
+  "SUM_LT" > "HOLLight.hollight.SUM_LT"
+  "SUM_LMUL" > "HOLLight.hollight.SUM_LMUL"
+  "SUM_LE_NUMSEG" > "HOLLight.hollight.SUM_LE_NUMSEG"
+  "SUM_LE_INCLUDED" > "HOLLight.hollight.SUM_LE_INCLUDED"
+  "SUM_LE" > "HOLLight.hollight.SUM_LE"
+  "SUM_INJECTION" > "HOLLight.hollight.SUM_INJECTION"
+  "SUM_INCL_EXCL" > "HOLLight.hollight.SUM_INCL_EXCL"
+  "SUM_IMAGE_NONZERO" > "HOLLight.hollight.SUM_IMAGE_NONZERO"
+  "SUM_IMAGE_LE" > "HOLLight.hollight.SUM_IMAGE_LE"
+  "SUM_IMAGE_GEN" > "HOLLight.hollight.SUM_IMAGE_GEN"
+  "SUM_IMAGE" > "HOLLight.hollight.SUM_IMAGE"
+  "SUM_GROUP" > "HOLLight.hollight.SUM_GROUP"
+  "SUM_EQ_SUPERSET" > "HOLLight.hollight.SUM_EQ_SUPERSET"
+  "SUM_EQ_NUMSEG" > "HOLLight.hollight.SUM_EQ_NUMSEG"
+  "SUM_EQ_GENERAL_INVERSES" > "HOLLight.hollight.SUM_EQ_GENERAL_INVERSES"
+  "SUM_EQ_GENERAL" > "HOLLight.hollight.SUM_EQ_GENERAL"
+  "SUM_EQ_0_NUMSEG" > "HOLLight.hollight.SUM_EQ_0_NUMSEG"
+  "SUM_EQ_0" > "HOLLight.hollight.SUM_EQ_0"
+  "SUM_EQ" > "HOLLight.hollight.SUM_EQ"
+  "SUM_DIFFS_ALT" > "HOLLight.hollight.SUM_DIFFS_ALT"
+  "SUM_DIFFS" > "HOLLight.hollight.SUM_DIFFS"
+  "SUM_DIFF" > "HOLLight.hollight.SUM_DIFF"
+  "SUM_DELTA" > "HOLLight.hollight.SUM_DELTA"
+  "SUM_DELETE_CASES" > "HOLLight.hollight.SUM_DELETE_CASES"
+  "SUM_DELETE" > "HOLLight.hollight.SUM_DELETE"
+  "SUM_CONST_NUMSEG" > "HOLLight.hollight.SUM_CONST_NUMSEG"
+  "SUM_CONST" > "HOLLight.hollight.SUM_CONST"
+  "SUM_COMBINE_R" > "HOLLight.hollight.SUM_COMBINE_R"
+  "SUM_COMBINE_L" > "HOLLight.hollight.SUM_COMBINE_L"
+  "SUM_CLOSED" > "HOLLight.hollight.SUM_CLOSED"
+  "SUM_CLAUSES_RIGHT" > "HOLLight.hollight.SUM_CLAUSES_RIGHT"
+  "SUM_CLAUSES_NUMSEG" > "HOLLight.hollight.SUM_CLAUSES_NUMSEG"
+  "SUM_CLAUSES_LEFT" > "HOLLight.hollight.SUM_CLAUSES_LEFT"
+  "SUM_CLAUSES" > "HOLLight.hollight.SUM_CLAUSES"
+  "SUM_CASES_1" > "HOLLight.hollight.SUM_CASES_1"
+  "SUM_CASES" > "HOLLight.hollight.SUM_CASES"
+  "SUM_BOUND_LT_GEN" > "HOLLight.hollight.SUM_BOUND_LT_GEN"
+  "SUM_BOUND_LT_ALL" > "HOLLight.hollight.SUM_BOUND_LT_ALL"
+  "SUM_BOUND_LT" > "HOLLight.hollight.SUM_BOUND_LT"
+  "SUM_BOUND_GEN" > "HOLLight.hollight.SUM_BOUND_GEN"
+  "SUM_BOUND" > "HOLLight.hollight.SUM_BOUND"
+  "SUM_BIJECTION" > "HOLLight.hollight.SUM_BIJECTION"
+  "SUM_ADD_SPLIT" > "HOLLight.hollight.SUM_ADD_SPLIT"
+  "SUM_ADD_NUMSEG" > "HOLLight.hollight.SUM_ADD_NUMSEG"
+  "SUM_ADD_GEN" > "HOLLight.hollight.SUM_ADD_GEN"
+  "SUM_ADD" > "HOLLight.hollight.SUM_ADD"
+  "SUM_ABS_NUMSEG" > "HOLLight.hollight.SUM_ABS_NUMSEG"
+  "SUM_ABS_LE" > "HOLLight.hollight.SUM_ABS_LE"
+  "SUM_ABS_BOUND" > "HOLLight.hollight.SUM_ABS_BOUND"
+  "SUM_ABS" > "HOLLight.hollight.SUM_ABS"
+  "SUM_0" > "HOLLight.hollight.SUM_0"
+  "SUC_SUB1" > "Nat.diff_Suc_1"
+  "SUC_INJ" > "HOLLightCompat.SUC_INJ"
+  "SUB_SUC" > "Nat.diff_Suc_Suc"
+  "SUB_REFL" > "Nat.diff_self_eq_0"
+  "SUB_PRESUC" > "HOLLight.hollight.SUB_PRESUC"
+  "SUB_EQ_0" > "Nat.diff_is_0_eq"
+  "SUB_ELIM_THM" > "HOLLight.hollight.SUB_ELIM_THM"
+  "SUB_ADD_RCANCEL" > "Nat.diff_cancel2"
+  "SUB_ADD_LCANCEL" > "Nat.diff_cancel"
+  "SUB_ADD" > "Nat.le_add_diff_inverse2"
+  "SUB_0" > "HOLLight.hollight.SUB_0"
+  "SUBSET_UNIV" > "Orderings.top_class.top_greatest"
+  "SUBSET_UNION_ABSORPTION" > "Lattices.semilattice_sup_class.le_iff_sup"
+  "SUBSET_UNIONS" > "Complete_Lattices.Union_mono"
+  "SUBSET_UNION" > "HOLLight.hollight.SUBSET_UNION"
+  "SUBSET_TRANS" > "Orderings.order_trans_rules_23"
+  "SUBSET_RESTRICT" > "HOLLight.hollight.SUBSET_RESTRICT"
+  "SUBSET_REFL" > "Inductive.basic_monos_1"
+  "SUBSET_PSUBSET_TRANS" > "Orderings.order_le_less_trans"
+  "SUBSET_NUMSEG" > "HOLLight.hollight.SUBSET_NUMSEG"
+  "SUBSET_INTER_ABSORPTION" > "Lattices.semilattice_inf_class.le_iff_inf"
+  "SUBSET_INTER" > "Lattices.semilattice_inf_class.le_inf_iff"
+  "SUBSET_INSERT_DELETE" > "HOLLight.hollight.SUBSET_INSERT_DELETE"
+  "SUBSET_INSERT" > "Set.subset_insert"
+  "SUBSET_IMAGE" > "Set.subset_image_iff"
+  "SUBSET_EMPTY" > "Orderings.bot_class.bot_unique"
+  "SUBSET_DIFF" > "Set.Diff_subset"
+  "SUBSET_DELETE" > "HOLLight.hollight.SUBSET_DELETE"
+  "SUBSET_CARD_EQ" > "HOLLight.hollight.SUBSET_CARD_EQ"
+  "SUBSET_ANTISYM_EQ" > "Orderings.order_class.eq_iff"
+  "SUBSET_ANTISYM" > "Orderings.order_antisym"
+  "SND" > "Product_Type.snd_conv"
+  "SKOLEM_THM" > "HOLLight.hollight.SKOLEM_THM"
+  "SING_def" > "HOLLight.hollight.SING_def"
+  "SING_SUBSET" > "HOLLight.hollight.SING_SUBSET"
+  "SING_GSPEC" > "HOLLight.hollight.SING_GSPEC"
+  "SIMPLE_IMAGE_GEN" > "HOLLight.hollight.SIMPLE_IMAGE_GEN"
+  "SIMPLE_IMAGE" > "HOLLight.hollight.SIMPLE_IMAGE"
+  "SET_RECURSION_LEMMA" > "HOLLight.hollight.SET_RECURSION_LEMMA"
+  "SET_PROVE_CASES" > "HOLLight.hollight.SET_PROVE_CASES"
+  "SET_PAIR_THM" > "HOLLight.hollight.SET_PAIR_THM"
+  "SET_OF_LIST_MAP" > "List.set_map"
+  "SET_OF_LIST_EQ_EMPTY" > "List.set_empty"
+  "SET_OF_LIST_APPEND" > "List.set_append"
+  "SET_CASES" > "HOLLight.hollight.SET_CASES"
+  "SEMIRING_PTHS" > "HOLLight.hollight.SEMIRING_PTHS"
+  "SELECT_UNIQUE" > "HOLLight.hollight.SELECT_UNIQUE"
+  "SELECT_REFL" > "Hilbert_Choice.some_eq_trivial"
+  "SELECT_LEMMA" > "Hilbert_Choice.some_sym_eq_trivial"
+  "RIGHT_SUB_DISTRIB" > "Nat.diff_mult_distrib"
+  "RIGHT_OR_FORALL_THM" > "HOL.all_simps_4"
+  "RIGHT_OR_EXISTS_THM" > "HOL.ex_simps_4"
+  "RIGHT_OR_DISTRIB" > "Groebner_Basis.dnf_2"
+  "RIGHT_IMP_FORALL_THM" > "HOL.all_simps_6"
+  "RIGHT_IMP_EXISTS_THM" > "HOL.ex_simps_6"
+  "RIGHT_FORALL_OR_THM" > "HOL.all_simps_4"
+  "RIGHT_FORALL_IMP_THM" > "HOL.all_simps_6"
+  "RIGHT_EXISTS_IMP_THM" > "HOL.ex_simps_6"
+  "RIGHT_EXISTS_AND_THM" > "HOL.ex_simps_2"
+  "RIGHT_AND_FORALL_THM" > "HOL.all_simps_2"
+  "RIGHT_AND_EXISTS_THM" > "HOL.ex_simps_2"
+  "RIGHT_ADD_DISTRIB" > "Fields.linordered_field_class.sign_simps_26"
+  "REVERSE_REVERSE" > "List.rev_rev_ident"
+  "REVERSE_APPEND" > "List.rev_append"
+  "REST_def" > "HOLLight.hollight.REST_def"
+  "REFL_CLAUSE" > "Groebner_Basis.bool_simps_6"
+  "REAL_WLOG_LT" > "HOLLight.hollight.REAL_WLOG_LT"
+  "REAL_WLOG_LE" > "HOLLight.hollight.REAL_WLOG_LE"
+  "REAL_SUB_TRIANGLE" > "HOLLight.hollight.REAL_SUB_TRIANGLE"
+  "REAL_SUB_SUB2" > "HOLLight.hollight.REAL_SUB_SUB2"
+  "REAL_SUB_SUB" > "HOLLight.hollight.REAL_SUB_SUB"
+  "REAL_SUB_RZERO" > "HOLLight.hollight.REAL_SUB_RZERO"
+  "REAL_SUB_RNEG" > "HOLLight.hollight.REAL_SUB_RNEG"
+  "REAL_SUB_REFL" > "HOLLight.hollight.REAL_SUB_REFL"
+  "REAL_SUB_RDISTRIB" > "HOLLight.hollight.REAL_SUB_RDISTRIB"
+  "REAL_SUB_POW_R1" > "HOLLight.hollight.REAL_SUB_POW_R1"
+  "REAL_SUB_POW_L1" > "HOLLight.hollight.REAL_SUB_POW_L1"
+  "REAL_SUB_POW" > "HOLLight.hollight.REAL_SUB_POW"
+  "REAL_SUB_NEG2" > "HOLLight.hollight.REAL_SUB_NEG2"
+  "REAL_SUB_LZERO" > "HOLLight.hollight.REAL_SUB_LZERO"
+  "REAL_SUB_LT" > "HOLLight.hollight.REAL_SUB_LT"
+  "REAL_SUB_LNEG" > "HOLLight.hollight.REAL_SUB_LNEG"
+  "REAL_SUB_LE" > "HOLLight.hollight.REAL_SUB_LE"
+  "REAL_SUB_LDISTRIB" > "HOLLight.hollight.REAL_SUB_LDISTRIB"
+  "REAL_SUB_INV" > "HOLLight.hollight.REAL_SUB_INV"
+  "REAL_SUB_ADD2" > "HOLLight.hollight.REAL_SUB_ADD2"
+  "REAL_SUB_ADD" > "HOLLight.hollight.REAL_SUB_ADD"
+  "REAL_SUB_ABS" > "HOLLight.hollight.REAL_SUB_ABS"
+  "REAL_SUB_0" > "HOLLight.hollight.REAL_SUB_0"
+  "REAL_SOS_EQ_0" > "HOLLight.hollight.REAL_SOS_EQ_0"
+  "REAL_SGN_NEG" > "HOLLight.hollight.REAL_SGN_NEG"
+  "REAL_SGN_MUL" > "HOLLight.hollight.REAL_SGN_MUL"
+  "REAL_SGN_INV" > "HOLLight.hollight.REAL_SGN_INV"
+  "REAL_SGN_DIV" > "HOLLight.hollight.REAL_SGN_DIV"
+  "REAL_SGN_ABS" > "HOLLight.hollight.REAL_SGN_ABS"
+  "REAL_SGN_0" > "HOLLight.hollight.REAL_SGN_0"
+  "REAL_SGN" > "HOLLight.hollight.REAL_SGN"
+  "REAL_RNEG_UNIQ" > "HOLLight.hollight.REAL_RNEG_UNIQ"
+  "REAL_POW_ZERO" > "HOLLight.hollight.REAL_POW_ZERO"
+  "REAL_POW_SUB" > "HOLLight.hollight.REAL_POW_SUB"
+  "REAL_POW_POW" > "HOLLight.hollight.REAL_POW_POW"
+  "REAL_POW_ONE" > "HOLLight.hollight.REAL_POW_ONE"
+  "REAL_POW_NZ" > "HOLLight.hollight.REAL_POW_NZ"
+  "REAL_POW_NEG" > "HOLLight.hollight.REAL_POW_NEG"
+  "REAL_POW_MUL" > "HOLLight.hollight.REAL_POW_MUL"
+  "REAL_POW_MONO_LT" > "HOLLight.hollight.REAL_POW_MONO_LT"
+  "REAL_POW_MONO_INV" > "HOLLight.hollight.REAL_POW_MONO_INV"
+  "REAL_POW_MONO" > "HOLLight.hollight.REAL_POW_MONO"
+  "REAL_POW_LT_1" > "HOLLight.hollight.REAL_POW_LT_1"
+  "REAL_POW_LT2_REV" > "HOLLight.hollight.REAL_POW_LT2_REV"
+  "REAL_POW_LT2_ODD_EQ" > "HOLLight.hollight.REAL_POW_LT2_ODD_EQ"
+  "REAL_POW_LT2_ODD" > "HOLLight.hollight.REAL_POW_LT2_ODD"
+  "REAL_POW_LT2" > "HOLLight.hollight.REAL_POW_LT2"
+  "REAL_POW_LT" > "HOLLight.hollight.REAL_POW_LT"
+  "REAL_POW_LE_1" > "HOLLight.hollight.REAL_POW_LE_1"
+  "REAL_POW_LE2_REV" > "HOLLight.hollight.REAL_POW_LE2_REV"
+  "REAL_POW_LE2_ODD_EQ" > "HOLLight.hollight.REAL_POW_LE2_ODD_EQ"
+  "REAL_POW_LE2_ODD" > "HOLLight.hollight.REAL_POW_LE2_ODD"
+  "REAL_POW_LE2" > "HOLLight.hollight.REAL_POW_LE2"
+  "REAL_POW_LE" > "HOLLight.hollight.REAL_POW_LE"
+  "REAL_POW_INV" > "HOLLight.hollight.REAL_POW_INV"
+  "REAL_POW_EQ_ODD_EQ" > "HOLLight.hollight.REAL_POW_EQ_ODD_EQ"
+  "REAL_POW_EQ_ODD" > "HOLLight.hollight.REAL_POW_EQ_ODD"
+  "REAL_POW_EQ_EQ" > "HOLLight.hollight.REAL_POW_EQ_EQ"
+  "REAL_POW_EQ_ABS" > "HOLLight.hollight.REAL_POW_EQ_ABS"
+  "REAL_POW_EQ_1_IMP" > "HOLLight.hollight.REAL_POW_EQ_1_IMP"
+  "REAL_POW_EQ_1" > "HOLLight.hollight.REAL_POW_EQ_1"
+  "REAL_POW_EQ_0" > "HOLLight.hollight.REAL_POW_EQ_0"
+  "REAL_POW_EQ" > "HOLLight.hollight.REAL_POW_EQ"
+  "REAL_POW_DIV" > "HOLLight.hollight.REAL_POW_DIV"
+  "REAL_POW_ADD" > "HOLLight.hollight.REAL_POW_ADD"
+  "REAL_POW_2" > "HOLLight.hollight.REAL_POW_2"
+  "REAL_POW_1_LT" > "HOLLight.hollight.REAL_POW_1_LT"
+  "REAL_POW_1_LE" > "HOLLight.hollight.REAL_POW_1_LE"
+  "REAL_POW_1" > "HOLLight.hollight.REAL_POW_1"
+  "REAL_POW2_ABS" > "HOLLight.hollight.REAL_POW2_ABS"
+  "REAL_POS_NZ" > "HOLLight.hollight.REAL_POS_NZ"
+  "REAL_POS" > "HOLLight.hollight.REAL_POS"
+  "REAL_POLY_NEG_CLAUSES" > "HOLLight.hollight.REAL_POLY_NEG_CLAUSES"
+  "REAL_POLY_CLAUSES" > "HOLLight.hollight.REAL_POLY_CLAUSES"
+  "REAL_OF_NUM_SUM_NUMSEG" > "HOLLight.hollight.REAL_OF_NUM_SUM_NUMSEG"
+  "REAL_OF_NUM_SUM" > "HOLLight.hollight.REAL_OF_NUM_SUM"
+  "REAL_OF_NUM_SUC" > "HOLLight.hollight.REAL_OF_NUM_SUC"
+  "REAL_OF_NUM_SUB" > "HOLLight.hollight.REAL_OF_NUM_SUB"
+  "REAL_OF_NUM_POW" > "HOLLight.hollight.REAL_OF_NUM_POW"
+  "REAL_OF_NUM_MIN" > "HOLLight.hollight.REAL_OF_NUM_MIN"
+  "REAL_OF_NUM_MAX" > "HOLLight.hollight.REAL_OF_NUM_MAX"
+  "REAL_OF_NUM_LT" > "HOLLight.hollight.REAL_OF_NUM_LT"
+  "REAL_OF_NUM_GT" > "HOLLight.hollight.REAL_OF_NUM_GT"
+  "REAL_OF_NUM_GE" > "HOLLight.hollight.REAL_OF_NUM_GE"
+  "REAL_NOT_LT" > "HOLLight.hollight.REAL_NOT_LT"
+  "REAL_NOT_LE" > "HOLLight.hollight.real_lt_def"
+  "REAL_NOT_EQ" > "HOLLight.hollight.REAL_NOT_EQ"
+  "REAL_NEG_SUB" > "HOLLight.hollight.REAL_NEG_SUB"
+  "REAL_NEG_RMUL" > "HOLLight.hollight.REAL_NEG_RMUL"
+  "REAL_NEG_NEG" > "HOLLight.hollight.REAL_NEG_NEG"
+  "REAL_NEG_MUL2" > "HOLLight.hollight.REAL_NEG_MUL2"
+  "REAL_NEG_MINUS1" > "HOLLight.hollight.REAL_NEG_MINUS1"
+  "REAL_NEG_LT0" > "HOLLight.hollight.REAL_NEG_LT0"
+  "REAL_NEG_LMUL" > "HOLLight.hollight.REAL_NEG_LMUL"
+  "REAL_NEG_LE0" > "HOLLight.hollight.REAL_NEG_LE0"
+  "REAL_NEG_GT0" > "HOLLight.hollight.REAL_NEG_GT0"
+  "REAL_NEG_GE0" > "HOLLight.hollight.REAL_NEG_GE0"
+  "REAL_NEG_EQ_0" > "HOLLight.hollight.REAL_NEG_EQ_0"
+  "REAL_NEG_EQ" > "HOLLight.hollight.REAL_NEG_EQ"
+  "REAL_NEG_ADD" > "HOLLight.hollight.REAL_NEG_ADD"
+  "REAL_NEG_0" > "HOLLight.hollight.REAL_NEG_0"
+  "REAL_NEGNEG" > "HOLLight.hollight.REAL_NEGNEG"
+  "REAL_MUL_RZERO" > "HOLLight.hollight.REAL_MUL_RZERO"
+  "REAL_MUL_RNEG" > "HOLLight.hollight.REAL_MUL_RNEG"
+  "REAL_MUL_RINV_UNIQ" > "HOLLight.hollight.REAL_MUL_RINV_UNIQ"
+  "REAL_MUL_RINV" > "HOLLight.hollight.REAL_MUL_RINV"
+  "REAL_MUL_RID" > "HOLLight.hollight.REAL_MUL_RID"
+  "REAL_MUL_POS_LT" > "HOLLight.hollight.REAL_MUL_POS_LT"
+  "REAL_MUL_POS_LE" > "HOLLight.hollight.REAL_MUL_POS_LE"
+  "REAL_MUL_LZERO" > "HOLLight.hollight.REAL_MUL_LZERO"
+  "REAL_MUL_LNEG" > "HOLLight.hollight.REAL_MUL_LNEG"
+  "REAL_MUL_LINV_UNIQ" > "HOLLight.hollight.REAL_MUL_LINV_UNIQ"
+  "REAL_MUL_AC" > "HOLLight.hollight.REAL_MUL_AC"
+  "REAL_MUL_2" > "HOLLight.hollight.REAL_MUL_2"
+  "REAL_MIN_SYM" > "HOLLight.hollight.REAL_MIN_SYM"
+  "REAL_MIN_MIN" > "HOLLight.hollight.REAL_MIN_MIN"
+  "REAL_MIN_MAX" > "HOLLight.hollight.REAL_MIN_MAX"
+  "REAL_MIN_LT" > "HOLLight.hollight.REAL_MIN_LT"
+  "REAL_MIN_LE" > "HOLLight.hollight.REAL_MIN_LE"
+  "REAL_MIN_ASSOC" > "HOLLight.hollight.REAL_MIN_ASSOC"
+  "REAL_MIN_ACI" > "HOLLight.hollight.REAL_MIN_ACI"
+  "REAL_MAX_SYM" > "HOLLight.hollight.REAL_MAX_SYM"
+  "REAL_MAX_MIN" > "HOLLight.hollight.REAL_MAX_MIN"
+  "REAL_MAX_MAX" > "HOLLight.hollight.REAL_MAX_MAX"
+  "REAL_MAX_LT" > "HOLLight.hollight.REAL_MAX_LT"
+  "REAL_MAX_LE" > "HOLLight.hollight.REAL_MAX_LE"
+  "REAL_MAX_ASSOC" > "HOLLight.hollight.REAL_MAX_ASSOC"
+  "REAL_MAX_ACI" > "HOLLight.hollight.REAL_MAX_ACI"
+  "REAL_LT_TRANS" > "HOLLight.hollight.REAL_LT_TRANS"
+  "REAL_LT_TOTAL" > "HOLLight.hollight.REAL_LT_TOTAL"
+  "REAL_LT_SUB_RADD" > "HOLLight.hollight.REAL_LT_SUB_RADD"
+  "REAL_LT_SUB_LADD" > "HOLLight.hollight.REAL_LT_SUB_LADD"
+  "REAL_LT_SQUARE_ABS" > "HOLLight.hollight.REAL_LT_SQUARE_ABS"
+  "REAL_LT_SQUARE" > "HOLLight.hollight.REAL_LT_SQUARE"
+  "REAL_LT_RNEG" > "HOLLight.hollight.REAL_LT_RNEG"
+  "REAL_LT_RMUL_EQ" > "HOLLight.hollight.REAL_LT_RMUL_EQ"
+  "REAL_LT_RMUL" > "HOLLight.hollight.REAL_LT_RMUL"
+  "REAL_LT_RINV" > "HOLLight.hollight.REAL_LT_RINV"
+  "REAL_LT_REFL" > "HOLLight.hollight.REAL_LT_REFL"
+  "REAL_LT_RDIV_EQ" > "HOLLight.hollight.REAL_LT_RDIV_EQ"
+  "REAL_LT_RCANCEL_IMP" > "HOLLight.hollight.REAL_LT_RCANCEL_IMP"
+  "REAL_LT_RADD" > "HOLLight.hollight.REAL_LT_RADD"
+  "REAL_LT_POW2" > "HOLLight.hollight.REAL_LT_POW2"
+  "REAL_LT_NEGTOTAL" > "HOLLight.hollight.REAL_LT_NEGTOTAL"
+  "REAL_LT_NEG2" > "HOLLight.hollight.REAL_LT_NEG2"
+  "REAL_LT_NEG" > "HOLLight.hollight.REAL_LT_NEG"
+  "REAL_LT_MUL_EQ" > "HOLLight.hollight.REAL_LT_MUL_EQ"
+  "REAL_LT_MUL2" > "HOLLight.hollight.REAL_LT_MUL2"
+  "REAL_LT_MUL" > "HOLLight.hollight.REAL_LT_MUL"
+  "REAL_LT_MIN" > "HOLLight.hollight.REAL_LT_MIN"
+  "REAL_LT_MAX" > "HOLLight.hollight.REAL_LT_MAX"
+  "REAL_LT_LNEG" > "HOLLight.hollight.REAL_LT_LNEG"
+  "REAL_LT_LMUL_EQ" > "HOLLight.hollight.REAL_LT_LMUL_EQ"
+  "REAL_LT_LMUL" > "HOLLight.hollight.REAL_LT_LMUL"
+  "REAL_LT_LINV" > "HOLLight.hollight.REAL_LT_LINV"
+  "REAL_LT_LE" > "HOLLight.hollight.REAL_LT_LE"
+  "REAL_LT_LDIV_EQ" > "HOLLight.hollight.REAL_LT_LDIV_EQ"
+  "REAL_LT_LCANCEL_IMP" > "HOLLight.hollight.REAL_LT_LCANCEL_IMP"
+  "REAL_LT_LADD_IMP" > "HOLLight.hollight.REAL_LT_LADD_IMP"
+  "REAL_LT_LADD" > "HOLLight.hollight.REAL_LT_LADD"
+  "REAL_LT_INV_EQ" > "HOLLight.hollight.REAL_LT_INV_EQ"
+  "REAL_LT_INV2" > "HOLLight.hollight.REAL_LT_INV2"
+  "REAL_LT_INV" > "HOLLight.hollight.REAL_LT_INV"
+  "REAL_LT_IMP_NZ" > "HOLLight.hollight.REAL_LT_IMP_NZ"
+  "REAL_LT_IMP_NE" > "HOLLight.hollight.REAL_LT_IMP_NE"
+  "REAL_LT_IMP_LE" > "HOLLight.hollight.REAL_LT_IMP_LE"
+  "REAL_LT_GT" > "HOLLight.hollight.REAL_LT_GT"
+  "REAL_LT_DIV2_EQ" > "HOLLight.hollight.REAL_LT_DIV2_EQ"
+  "REAL_LT_DIV" > "HOLLight.hollight.REAL_LT_DIV"
+  "REAL_LT_ANTISYM" > "HOLLight.hollight.REAL_LT_ANTISYM"
+  "REAL_LT_ADD_SUB" > "HOLLight.hollight.REAL_LT_ADD_SUB"
+  "REAL_LT_ADDR" > "HOLLight.hollight.REAL_LT_ADDR"
+  "REAL_LT_ADDNEG2" > "HOLLight.hollight.REAL_LT_ADDNEG2"
+  "REAL_LT_ADDNEG" > "HOLLight.hollight.REAL_LT_ADDNEG"
+  "REAL_LT_ADDL" > "HOLLight.hollight.REAL_LT_ADDL"
+  "REAL_LT_ADD2" > "HOLLight.hollight.REAL_LT_ADD2"
+  "REAL_LT_ADD1" > "HOLLight.hollight.REAL_LT_ADD1"
+  "REAL_LT_ADD" > "HOLLight.hollight.REAL_LT_ADD"
+  "REAL_LT_01" > "HOLLight.hollight.REAL_LT_01"
+  "REAL_LTE_TRANS" > "HOLLight.hollight.REAL_LTE_TRANS"
+  "REAL_LTE_TOTAL" > "HOLLight.hollight.REAL_LTE_TOTAL"
+  "REAL_LTE_ANTISYM" > "HOLLight.hollight.REAL_LTE_ANTISYM"
+  "REAL_LTE_ADD2" > "HOLLight.hollight.REAL_LTE_ADD2"
+  "REAL_LTE_ADD" > "HOLLight.hollight.REAL_LTE_ADD"
+  "REAL_LNEG_UNIQ" > "HOLLight.hollight.REAL_LNEG_UNIQ"
+  "REAL_LE_SUB_RADD" > "HOLLight.hollight.REAL_LE_SUB_RADD"
+  "REAL_LE_SUB_LADD" > "HOLLight.hollight.REAL_LE_SUB_LADD"
+  "REAL_LE_SQUARE_ABS" > "HOLLight.hollight.REAL_LE_SQUARE_ABS"
+  "REAL_LE_SQUARE" > "HOLLight.hollight.REAL_LE_SQUARE"
+  "REAL_LE_RNEG" > "HOLLight.hollight.REAL_LE_RNEG"
+  "REAL_LE_RMUL_EQ" > "HOLLight.hollight.REAL_LE_RMUL_EQ"
+  "REAL_LE_RMUL" > "HOLLight.hollight.REAL_LE_RMUL"
+  "REAL_LE_RINV" > "HOLLight.hollight.REAL_LE_RINV"
+  "REAL_LE_RDIV_EQ" > "HOLLight.hollight.REAL_LE_RDIV_EQ"
+  "REAL_LE_RCANCEL_IMP" > "HOLLight.hollight.REAL_LE_RCANCEL_IMP"
+  "REAL_LE_RADD" > "HOLLight.hollight.REAL_LE_RADD"
+  "REAL_LE_POW_2" > "HOLLight.hollight.REAL_LE_POW_2"
+  "REAL_LE_POW2" > "HOLLight.hollight.REAL_LE_POW2"
+  "REAL_LE_NEGTOTAL" > "HOLLight.hollight.REAL_LE_NEGTOTAL"
+  "REAL_LE_NEGR" > "HOLLight.hollight.REAL_LE_NEGR"
+  "REAL_LE_NEGL" > "HOLLight.hollight.REAL_LE_NEGL"
+  "REAL_LE_NEG2" > "HOLLight.hollight.REAL_LE_NEG2"
+  "REAL_LE_NEG" > "HOLLight.hollight.REAL_LE_NEG"
+  "REAL_LE_MUL_EQ" > "HOLLight.hollight.REAL_LE_MUL_EQ"
+  "REAL_LE_MUL2" > "HOLLight.hollight.REAL_LE_MUL2"
+  "REAL_LE_MIN" > "HOLLight.hollight.REAL_LE_MIN"
+  "REAL_LE_MAX" > "HOLLight.hollight.REAL_LE_MAX"
+  "REAL_LE_LT" > "HOLLight.hollight.REAL_LE_LT"
+  "REAL_LE_LNEG" > "HOLLight.hollight.REAL_LE_LNEG"
+  "REAL_LE_LMUL_EQ" > "HOLLight.hollight.REAL_LE_LMUL_EQ"
+  "REAL_LE_LMUL" > "HOLLight.hollight.REAL_LE_LMUL"
+  "REAL_LE_LINV" > "HOLLight.hollight.REAL_LE_LINV"
+  "REAL_LE_LDIV_EQ" > "HOLLight.hollight.REAL_LE_LDIV_EQ"
+  "REAL_LE_LCANCEL_IMP" > "HOLLight.hollight.REAL_LE_LCANCEL_IMP"
+  "REAL_LE_LADD" > "HOLLight.hollight.REAL_LE_LADD"
+  "REAL_LE_INV_EQ" > "HOLLight.hollight.REAL_LE_INV_EQ"
+  "REAL_LE_INV2" > "HOLLight.hollight.REAL_LE_INV2"
+  "REAL_LE_INV" > "HOLLight.hollight.REAL_LE_INV"
+  "REAL_LE_DOUBLE" > "HOLLight.hollight.REAL_LE_DOUBLE"
+  "REAL_LE_DIV2_EQ" > "HOLLight.hollight.REAL_LE_DIV2_EQ"
+  "REAL_LE_DIV" > "HOLLight.hollight.REAL_LE_DIV"
+  "REAL_LE_ADDR" > "HOLLight.hollight.REAL_LE_ADDR"
+  "REAL_LE_ADDL" > "HOLLight.hollight.REAL_LE_ADDL"
+  "REAL_LE_ADD2" > "HOLLight.hollight.REAL_LE_ADD2"
+  "REAL_LE_ADD" > "HOLLight.hollight.REAL_LE_ADD"
+  "REAL_LE_01" > "HOLLight.hollight.REAL_LE_01"
+  "REAL_LET_TRANS" > "HOLLight.hollight.REAL_LET_TRANS"
+  "REAL_LET_TOTAL" > "HOLLight.hollight.REAL_LET_TOTAL"
+  "REAL_LET_ANTISYM" > "HOLLight.hollight.REAL_LET_ANTISYM"
+  "REAL_LET_ADD2" > "HOLLight.hollight.REAL_LET_ADD2"
+  "REAL_LET_ADD" > "HOLLight.hollight.REAL_LET_ADD"
+  "REAL_INV_POW" > "HOLLight.hollight.REAL_INV_POW"
+  "REAL_INV_NEG" > "HOLLight.hollight.REAL_INV_NEG"
+  "REAL_INV_MUL" > "HOLLight.hollight.REAL_INV_MUL"
+  "REAL_INV_LT_1" > "HOLLight.hollight.REAL_INV_LT_1"
+  "REAL_INV_LE_1" > "HOLLight.hollight.REAL_INV_LE_1"
+  "REAL_INV_INV" > "HOLLight.hollight.REAL_INV_INV"
+  "REAL_INV_EQ_1" > "HOLLight.hollight.REAL_INV_EQ_1"
+  "REAL_INV_EQ_0" > "HOLLight.hollight.REAL_INV_EQ_0"
+  "REAL_INV_DIV" > "HOLLight.hollight.REAL_INV_DIV"
+  "REAL_INV_1_LT" > "HOLLight.hollight.REAL_INV_1_LT"
+  "REAL_INV_1_LE" > "HOLLight.hollight.REAL_INV_1_LE"
+  "REAL_INV_1" > "HOLLight.hollight.REAL_INV_1"
+  "REAL_INTEGRAL" > "HOLLight.hollight.REAL_INTEGRAL"
+  "REAL_HREAL_LEMMA2" > "HOLLight.hollight.REAL_HREAL_LEMMA2"
+  "REAL_HREAL_LEMMA1" > "HOLLight.hollight.REAL_HREAL_LEMMA1"
+  "REAL_EQ_SUB_RADD" > "HOLLight.hollight.REAL_EQ_SUB_RADD"
+  "REAL_EQ_SUB_LADD" > "HOLLight.hollight.REAL_EQ_SUB_LADD"
+  "REAL_EQ_SQUARE_ABS" > "HOLLight.hollight.REAL_EQ_SQUARE_ABS"
+  "REAL_EQ_RDIV_EQ" > "HOLLight.hollight.REAL_EQ_RDIV_EQ"
+  "REAL_EQ_RCANCEL_IMP" > "HOLLight.hollight.REAL_EQ_RCANCEL_IMP"
+  "REAL_EQ_NEG2" > "HOLLight.hollight.REAL_EQ_NEG2"
+  "REAL_EQ_MUL_RCANCEL" > "HOLLight.hollight.REAL_EQ_MUL_RCANCEL"
+  "REAL_EQ_MUL_LCANCEL" > "HOLLight.hollight.REAL_EQ_MUL_LCANCEL"
+  "REAL_EQ_LDIV_EQ" > "HOLLight.hollight.REAL_EQ_LDIV_EQ"
+  "REAL_EQ_LCANCEL_IMP" > "HOLLight.hollight.REAL_EQ_LCANCEL_IMP"
+  "REAL_EQ_INV2" > "HOLLight.hollight.REAL_EQ_INV2"
+  "REAL_EQ_IMP_LE" > "HOLLight.hollight.REAL_EQ_IMP_LE"
+  "REAL_EQ_ADD_RCANCEL_0" > "HOLLight.hollight.REAL_EQ_ADD_RCANCEL_0"
+  "REAL_EQ_ADD_RCANCEL" > "HOLLight.hollight.REAL_EQ_ADD_RCANCEL"
+  "REAL_EQ_ADD_LCANCEL_0" > "HOLLight.hollight.REAL_EQ_ADD_LCANCEL_0"
+  "REAL_EQ_ADD_LCANCEL" > "HOLLight.hollight.REAL_EQ_ADD_LCANCEL"
+  "REAL_ENTIRE" > "HOLLight.hollight.REAL_ENTIRE"
+  "REAL_DOWN2" > "HOLLight.hollight.REAL_DOWN2"
+  "REAL_DOWN" > "HOLLight.hollight.REAL_DOWN"
+  "REAL_DIV_RMUL" > "HOLLight.hollight.REAL_DIV_RMUL"
+  "REAL_DIV_REFL" > "HOLLight.hollight.REAL_DIV_REFL"
+  "REAL_DIV_POW2_ALT" > "HOLLight.hollight.REAL_DIV_POW2_ALT"
+  "REAL_DIV_POW2" > "HOLLight.hollight.REAL_DIV_POW2"
+  "REAL_DIV_LMUL" > "HOLLight.hollight.REAL_DIV_LMUL"
+  "REAL_DIV_1" > "HOLLight.hollight.REAL_DIV_1"
+  "REAL_DIFFSQ" > "HOLLight.hollight.REAL_DIFFSQ"
+  "REAL_COMPLETE_SOMEPOS" > "HOLLight.hollight.REAL_COMPLETE_SOMEPOS"
+  "REAL_COMPLETE" > "HOLLight.hollight.REAL_COMPLETE"
+  "REAL_BOUNDS_LT" > "HOLLight.hollight.REAL_BOUNDS_LT"
+  "REAL_BOUNDS_LE" > "HOLLight.hollight.REAL_BOUNDS_LE"
+  "REAL_ADD_SUB2" > "HOLLight.hollight.REAL_ADD_SUB2"
+  "REAL_ADD_SUB" > "HOLLight.hollight.REAL_ADD_SUB"
+  "REAL_ADD_RINV" > "HOLLight.hollight.REAL_ADD_RINV"
+  "REAL_ADD_RID" > "HOLLight.hollight.REAL_ADD_RID"
+  "REAL_ADD_RDISTRIB" > "HOLLight.hollight.REAL_ADD_RDISTRIB"
+  "REAL_ADD_AC" > "HOLLight.hollight.REAL_ADD_AC"
+  "REAL_ADD2_SUB2" > "HOLLight.hollight.REAL_ADD2_SUB2"
+  "REAL_ABS_ZERO" > "HOLLight.hollight.REAL_ABS_ZERO"
+  "REAL_ABS_TRIANGLE_LT" > "HOLLight.hollight.REAL_ABS_TRIANGLE_LT"
+  "REAL_ABS_TRIANGLE_LE" > "HOLLight.hollight.REAL_ABS_TRIANGLE_LE"
+  "REAL_ABS_TRIANGLE" > "HOLLight.hollight.REAL_ABS_TRIANGLE"
+  "REAL_ABS_SUB_ABS" > "HOLLight.hollight.REAL_ABS_SUB_ABS"
+  "REAL_ABS_SUB" > "HOLLight.hollight.REAL_ABS_SUB"
+  "REAL_ABS_STILLNZ" > "HOLLight.hollight.REAL_ABS_STILLNZ"
+  "REAL_ABS_SIGN2" > "HOLLight.hollight.REAL_ABS_SIGN2"
+  "REAL_ABS_SIGN" > "HOLLight.hollight.REAL_ABS_SIGN"
+  "REAL_ABS_SGN" > "HOLLight.hollight.REAL_ABS_SGN"
+  "REAL_ABS_REFL" > "HOLLight.hollight.REAL_ABS_REFL"
+  "REAL_ABS_POW" > "HOLLight.hollight.REAL_ABS_POW"
+  "REAL_ABS_POS" > "HOLLight.hollight.REAL_ABS_POS"
+  "REAL_ABS_NZ" > "HOLLight.hollight.REAL_ABS_NZ"
+  "REAL_ABS_NUM" > "HOLLight.hollight.REAL_ABS_NUM"
+  "REAL_ABS_NEG" > "HOLLight.hollight.REAL_ABS_NEG"
+  "REAL_ABS_MUL" > "HOLLight.hollight.REAL_ABS_MUL"
+  "REAL_ABS_LE" > "HOLLight.hollight.REAL_ABS_LE"
+  "REAL_ABS_INV" > "HOLLight.hollight.REAL_ABS_INV"
+  "REAL_ABS_DIV" > "HOLLight.hollight.REAL_ABS_DIV"
+  "REAL_ABS_CIRCLE" > "HOLLight.hollight.REAL_ABS_CIRCLE"
+  "REAL_ABS_CASES" > "HOLLight.hollight.REAL_ABS_CASES"
+  "REAL_ABS_BOUNDS" > "HOLLight.hollight.REAL_ABS_BOUNDS"
+  "REAL_ABS_BOUND" > "HOLLight.hollight.REAL_ABS_BOUND"
+  "REAL_ABS_BETWEEN2" > "HOLLight.hollight.REAL_ABS_BETWEEN2"
+  "REAL_ABS_BETWEEN1" > "HOLLight.hollight.REAL_ABS_BETWEEN1"
+  "REAL_ABS_BETWEEN" > "HOLLight.hollight.REAL_ABS_BETWEEN"
+  "REAL_ABS_ABS" > "HOLLight.hollight.REAL_ABS_ABS"
+  "REAL_ABS_1" > "HOLLight.hollight.REAL_ABS_1"
+  "REAL_ABS_0" > "HOLLight.hollight.REAL_ABS_0"
+  "RAT_LEMMA5" > "HOLLight.hollight.RAT_LEMMA5"
+  "RAT_LEMMA4" > "HOLLight.hollight.RAT_LEMMA4"
+  "RAT_LEMMA3" > "HOLLight.hollight.RAT_LEMMA3"
+  "RAT_LEMMA2" > "HOLLight.hollight.RAT_LEMMA2"
+  "RAT_LEMMA1" > "HOLLight.hollight.RAT_LEMMA1"
+  "PSUBSET_UNIV" > "HOLLight.hollight.PSUBSET_UNIV"
+  "PSUBSET_TRANS" > "Orderings.order_less_trans"
+  "PSUBSET_SUBSET_TRANS" > "Orderings.order_less_le_trans"
+  "PSUBSET_MEMBER" > "HOLLight.hollight.PSUBSET_MEMBER"
+  "PSUBSET_IRREFL" > "Orderings.order_less_irrefl"
+  "PSUBSET_INSERT_SUBSET" > "HOLLight.hollight.PSUBSET_INSERT_SUBSET"
+  "PSUBSET_ALT" > "HOLLight.hollight.PSUBSET_ALT"
+  "PRE_ELIM_THM" > "HOLLight.hollight.PRE_ELIM_THM"
+  "POWERSET_CLAUSES" > "HOLLight.hollight.POWERSET_CLAUSES"
+  "PASSOC_def" > "HOLLight.hollight.PASSOC_def"
+  "PAIR_SURJECTIVE" > "Product_Type.prod.nchotomy"
+  "PAIR_EXISTS_THM" > "HOLLight.hollight.PAIR_EXISTS_THM"
+  "PAIR_EQ" > "Product_Type.Pair_eq"
+  "PAIRWISE_def" > "HOLLight.hollight.PAIRWISE_def"
+  "PAIRWISE_SING" > "HOLLight.hollight.PAIRWISE_SING"
+  "PAIRWISE_MONO" > "HOLLight.hollight.PAIRWISE_MONO"
+  "PAIRWISE_EMPTY" > "HOLLight.hollight.PAIRWISE_EMPTY"
+  "PAIR" > "HOLLightCompat.PAIR"
+  "OR_EXISTS_THM" > "HOL.ex_disj_distrib"
+  "OR_CLAUSES" > "HOLLight.hollight.OR_CLAUSES"
+  "ONE" > "Nat.One_nat_def"
+  "ODD_SUB" > "HOLLight.hollight.ODD_SUB"
+  "ODD_MULT" > "HOLLight.hollight.ODD_MULT"
+  "ODD_MOD" > "HOLLight.hollight.ODD_MOD"
+  "ODD_EXP" > "HOLLight.hollight.ODD_EXP"
+  "ODD_EXISTS" > "Parity.odd_Suc_mult_two_ex"
+  "ODD_DOUBLE" > "HOLLight.hollight.ODD_DOUBLE"
+  "ODD_ADD" > "Parity.odd_add"
+  "NUM_REP_def" > "HOLLight.hollight.NUM_REP_def"
+  "NUM_OF_INT_OF_NUM" > "HOLLight.hollight.NUM_OF_INT_OF_NUM"
+  "NUM_OF_INT" > "HOLLight.hollight.NUM_OF_INT"
+  "NUM_INTEGRAL_LEMMA" > "HOLLight.hollight.NUM_INTEGRAL_LEMMA"
+  "NUM_INTEGRAL" > "HOLLight.hollight.NUM_INTEGRAL"
+  "NUM_GCD" > "HOLLight.hollight.NUM_GCD"
+  "NUMSUM_def" > "HOLLight.hollight.NUMSUM_def"
+  "NUMSUM_INJ" > "HOLLight.hollight.NUMSUM_INJ"
+  "NUMSND_def" > "HOLLight.hollight.NUMSND_def"
+  "NUMSEG_SING" > "SetInterval.order_class.atLeastAtMost_singleton"
+  "NUMSEG_RREC" > "HOLLight.hollight.NUMSEG_RREC"
+  "NUMSEG_REC" > "SetInterval.atLeastAtMostSuc_conv"
+  "NUMSEG_OFFSET_IMAGE" > "SetInterval.image_add_atLeastAtMost"
+  "NUMSEG_LT" > "HOLLight.hollight.NUMSEG_LT"
+  "NUMSEG_LREC" > "HOLLight.hollight.NUMSEG_LREC"
+  "NUMSEG_LE" > "HOLLight.hollight.NUMSEG_LE"
+  "NUMSEG_EMPTY" > "HOLLight.hollight.NUMSEG_EMPTY"
+  "NUMSEG_COMBINE_R" > "HOLLight.hollight.NUMSEG_COMBINE_R"
+  "NUMSEG_COMBINE_L" > "HOLLight.hollight.NUMSEG_COMBINE_L"
+  "NUMSEG_CLAUSES" > "HOLLight.hollight.NUMSEG_CLAUSES"
+  "NUMSEG_ADD_SPLIT" > "HOLLight.hollight.NUMSEG_ADD_SPLIT"
+  "NUMRIGHT_def" > "HOLLight.hollight.NUMRIGHT_def"
+  "NUMPAIR_def" > "HOLLight.hollight.NUMPAIR_def"
+  "NUMPAIR_INJ_LEMMA" > "HOLLight.hollight.NUMPAIR_INJ_LEMMA"
+  "NUMPAIR_INJ" > "HOLLight.hollight.NUMPAIR_INJ"
+  "NUMLEFT_def" > "HOLLight.hollight.NUMLEFT_def"
+  "NUMFST_def" > "HOLLight.hollight.NUMFST_def"
+  "NSUM_UNION_RZERO" > "HOLLight.hollight.NSUM_UNION_RZERO"
+  "NSUM_UNION_NONZERO" > "HOLLight.hollight.NSUM_UNION_NONZERO"
+  "NSUM_UNION_LZERO" > "HOLLight.hollight.NSUM_UNION_LZERO"
+  "NSUM_UNION_EQ" > "HOLLight.hollight.NSUM_UNION_EQ"
+  "NSUM_UNIONS_NONZERO" > "HOLLight.hollight.NSUM_UNIONS_NONZERO"
+  "NSUM_UNION" > "HOLLight.hollight.NSUM_UNION"
+  "NSUM_TRIV_NUMSEG" > "HOLLight.hollight.NSUM_TRIV_NUMSEG"
+  "NSUM_SWAP_NUMSEG" > "HOLLight.hollight.NSUM_SWAP_NUMSEG"
+  "NSUM_SWAP" > "HOLLight.hollight.NSUM_SWAP"
+  "NSUM_SUPPORT" > "HOLLight.hollight.NSUM_SUPPORT"
+  "NSUM_SUPERSET" > "HOLLight.hollight.NSUM_SUPERSET"
+  "NSUM_SUBSET_SIMPLE" > "HOLLight.hollight.NSUM_SUBSET_SIMPLE"
+  "NSUM_SUBSET" > "HOLLight.hollight.NSUM_SUBSET"
+  "NSUM_SING_NUMSEG" > "HOLLight.hollight.NSUM_SING_NUMSEG"
+  "NSUM_SING" > "HOLLight.hollight.NSUM_SING"
+  "NSUM_RMUL" > "HOLLight.hollight.NSUM_RMUL"
+  "NSUM_RESTRICT_SET" > "HOLLight.hollight.NSUM_RESTRICT_SET"
+  "NSUM_RESTRICT" > "HOLLight.hollight.NSUM_RESTRICT"
+  "NSUM_POS_BOUND" > "HOLLight.hollight.NSUM_POS_BOUND"
+  "NSUM_PAIR" > "HOLLight.hollight.NSUM_PAIR"
+  "NSUM_OFFSET_0" > "HOLLight.hollight.NSUM_OFFSET_0"
+  "NSUM_OFFSET" > "HOLLight.hollight.NSUM_OFFSET"
+  "NSUM_NSUM_RESTRICT" > "HOLLight.hollight.NSUM_NSUM_RESTRICT"
+  "NSUM_NSUM_PRODUCT" > "HOLLight.hollight.NSUM_NSUM_PRODUCT"
+  "NSUM_MULTICOUNT_GEN" > "HOLLight.hollight.NSUM_MULTICOUNT_GEN"
+  "NSUM_MULTICOUNT" > "HOLLight.hollight.NSUM_MULTICOUNT"
+  "NSUM_LT_ALL" > "HOLLight.hollight.NSUM_LT_ALL"
+  "NSUM_LT" > "HOLLight.hollight.NSUM_LT"
+  "NSUM_LMUL" > "HOLLight.hollight.NSUM_LMUL"
+  "NSUM_LE_NUMSEG" > "HOLLight.hollight.NSUM_LE_NUMSEG"
+  "NSUM_LE" > "HOLLight.hollight.NSUM_LE"
+  "NSUM_INJECTION" > "HOLLight.hollight.NSUM_INJECTION"
+  "NSUM_INCL_EXCL" > "HOLLight.hollight.NSUM_INCL_EXCL"
+  "NSUM_IMAGE_NONZERO" > "HOLLight.hollight.NSUM_IMAGE_NONZERO"
+  "NSUM_IMAGE_GEN" > "HOLLight.hollight.NSUM_IMAGE_GEN"
+  "NSUM_IMAGE" > "HOLLight.hollight.NSUM_IMAGE"
+  "NSUM_GROUP" > "HOLLight.hollight.NSUM_GROUP"
+  "NSUM_EQ_SUPERSET" > "HOLLight.hollight.NSUM_EQ_SUPERSET"
+  "NSUM_EQ_NUMSEG" > "HOLLight.hollight.NSUM_EQ_NUMSEG"
+  "NSUM_EQ_GENERAL_INVERSES" > "HOLLight.hollight.NSUM_EQ_GENERAL_INVERSES"
+  "NSUM_EQ_GENERAL" > "HOLLight.hollight.NSUM_EQ_GENERAL"
+  "NSUM_EQ_0_NUMSEG" > "HOLLight.hollight.NSUM_EQ_0_NUMSEG"
+  "NSUM_EQ_0_IFF_NUMSEG" > "HOLLight.hollight.NSUM_EQ_0_IFF_NUMSEG"
+  "NSUM_EQ_0_IFF" > "HOLLight.hollight.NSUM_EQ_0_IFF"
+  "NSUM_EQ_0" > "HOLLight.hollight.NSUM_EQ_0"
+  "NSUM_EQ" > "HOLLight.hollight.NSUM_EQ"
+  "NSUM_DIFF" > "HOLLight.hollight.NSUM_DIFF"
+  "NSUM_DELTA" > "HOLLight.hollight.NSUM_DELTA"
+  "NSUM_DELETE" > "HOLLight.hollight.NSUM_DELETE"
+  "NSUM_CONST_NUMSEG" > "HOLLight.hollight.NSUM_CONST_NUMSEG"
+  "NSUM_CONST" > "HOLLight.hollight.NSUM_CONST"
+  "NSUM_CLOSED" > "HOLLight.hollight.NSUM_CLOSED"
+  "NSUM_CLAUSES_RIGHT" > "HOLLight.hollight.NSUM_CLAUSES_RIGHT"
+  "NSUM_CLAUSES_NUMSEG" > "HOLLight.hollight.NSUM_CLAUSES_NUMSEG"
+  "NSUM_CLAUSES_LEFT" > "HOLLight.hollight.NSUM_CLAUSES_LEFT"
+  "NSUM_CLAUSES" > "HOLLight.hollight.NSUM_CLAUSES"
+  "NSUM_CASES" > "HOLLight.hollight.NSUM_CASES"
+  "NSUM_BOUND_LT_GEN" > "HOLLight.hollight.NSUM_BOUND_LT_GEN"
+  "NSUM_BOUND_LT_ALL" > "HOLLight.hollight.NSUM_BOUND_LT_ALL"
+  "NSUM_BOUND_LT" > "HOLLight.hollight.NSUM_BOUND_LT"
+  "NSUM_BOUND_GEN" > "HOLLight.hollight.NSUM_BOUND_GEN"
+  "NSUM_BOUND" > "HOLLight.hollight.NSUM_BOUND"
+  "NSUM_BIJECTION" > "HOLLight.hollight.NSUM_BIJECTION"
+  "NSUM_ADD_SPLIT" > "HOLLight.hollight.NSUM_ADD_SPLIT"
+  "NSUM_ADD_NUMSEG" > "HOLLight.hollight.NSUM_ADD_NUMSEG"
+  "NSUM_ADD_GEN" > "HOLLight.hollight.NSUM_ADD_GEN"
+  "NSUM_ADD" > "HOLLight.hollight.NSUM_ADD"
+  "NSUM_0" > "HOLLight.hollight.NSUM_0"
+  "NOT_UNIV_PSUBSET" > "Orderings.top_class.not_top_less"
+  "NOT_SUC" > "Nat.Suc_not_Zero"
+  "NOT_PSUBSET_EMPTY" > "Orderings.bot_class.not_less_bot"
+  "NOT_ODD" > "HOLLight.hollight.NOT_ODD"
+  "NOT_LT" > "Orderings.linorder_class.not_less"
+  "NOT_LE" > "Orderings.linorder_class.not_le"
+  "NOT_IN_EMPTY" > "HOLLight.hollight.NOT_IN_EMPTY"
+  "NOT_INSERT_EMPTY" > "Set.insert_not_empty"
+  "NOT_FORALL_THM" > "HOL.not_all"
+  "NOT_EXISTS_THM" > "HOL.not_ex"
+  "NOT_EX" > "HOLLightList.NOT_EX"
+  "NOT_EVEN" > "HOLLight.hollight.NOT_EVEN"
+  "NOT_EQUAL_SETS" > "HOLLight.hollight.NOT_EQUAL_SETS"
+  "NOT_EMPTY_INSERT" > "Set.empty_not_insert"
+  "NOT_CONS_NIL" > "List.list.distinct_2"
+  "NOT_CLAUSES_WEAK" > "HOLLight.hollight.NOT_CLAUSES_WEAK"
+  "NOT_ALL" > "HOLLightList.NOT_ALL"
+  "NEUTRAL_REAL_MUL" > "HOLLight.hollight.NEUTRAL_REAL_MUL"
+  "NEUTRAL_REAL_ADD" > "HOLLight.hollight.NEUTRAL_REAL_ADD"
+  "NEUTRAL_MUL" > "HOLLight.hollight.NEUTRAL_MUL"
+  "NEUTRAL_ADD" > "HOLLight.hollight.NEUTRAL_ADD"
+  "NADD_UBOUND" > "HOLLight.hollight.NADD_UBOUND"
+  "NADD_SUC" > "HOLLight.hollight.NADD_SUC"
+  "NADD_RDISTRIB" > "HOLLight.hollight.NADD_RDISTRIB"
+  "NADD_OF_NUM_WELLDEF" > "HOLLight.hollight.NADD_OF_NUM_WELLDEF"
+  "NADD_OF_NUM_MUL" > "HOLLight.hollight.NADD_OF_NUM_MUL"
+  "NADD_OF_NUM_LE" > "HOLLight.hollight.NADD_OF_NUM_LE"
+  "NADD_OF_NUM_EQ" > "HOLLight.hollight.NADD_OF_NUM_EQ"
+  "NADD_OF_NUM_ADD" > "HOLLight.hollight.NADD_OF_NUM_ADD"
+  "NADD_OF_NUM" > "HOLLight.hollight.NADD_OF_NUM"
+  "NADD_NONZERO" > "HOLLight.hollight.NADD_NONZERO"
+  "NADD_MUL_WELLDEF_LEMMA" > "HOLLight.hollight.NADD_MUL_WELLDEF_LEMMA"
+  "NADD_MUL_WELLDEF" > "HOLLight.hollight.NADD_MUL_WELLDEF"
+  "NADD_MUL_SYM" > "HOLLight.hollight.NADD_MUL_SYM"
+  "NADD_MUL_LINV_LEMMA8" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA8"
+  "NADD_MUL_LINV_LEMMA7a" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA7a"
+  "NADD_MUL_LINV_LEMMA7" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA7"
+  "NADD_MUL_LINV_LEMMA6" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA6"
+  "NADD_MUL_LINV_LEMMA5" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA5"
+  "NADD_MUL_LINV_LEMMA4" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA4"
+  "NADD_MUL_LINV_LEMMA3" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA3"
+  "NADD_MUL_LINV_LEMMA2" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA2"
+  "NADD_MUL_LINV_LEMMA1" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA1"
+  "NADD_MUL_LINV_LEMMA0" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA0"
+  "NADD_MUL_LINV" > "HOLLight.hollight.NADD_MUL_LINV"
+  "NADD_MUL_LID" > "HOLLight.hollight.NADD_MUL_LID"
+  "NADD_MUL_ASSOC" > "HOLLight.hollight.NADD_MUL_ASSOC"
+  "NADD_MULTIPLICATIVE" > "HOLLight.hollight.NADD_MULTIPLICATIVE"
+  "NADD_MUL" > "HOLLight.hollight.NADD_MUL"
+  "NADD_LE_WELLDEF_LEMMA" > "HOLLight.hollight.NADD_LE_WELLDEF_LEMMA"
+  "NADD_LE_WELLDEF" > "HOLLight.hollight.NADD_LE_WELLDEF"
+  "NADD_LE_TRANS" > "HOLLight.hollight.NADD_LE_TRANS"
+  "NADD_LE_TOTAL_LEMMA" > "HOLLight.hollight.NADD_LE_TOTAL_LEMMA"
+  "NADD_LE_TOTAL" > "HOLLight.hollight.NADD_LE_TOTAL"
+  "NADD_LE_RMUL" > "HOLLight.hollight.NADD_LE_RMUL"
+  "NADD_LE_REFL" > "HOLLight.hollight.NADD_LE_REFL"
+  "NADD_LE_RADD" > "HOLLight.hollight.NADD_LE_RADD"
+  "NADD_LE_LMUL" > "HOLLight.hollight.NADD_LE_LMUL"
+  "NADD_LE_LADD" > "HOLLight.hollight.NADD_LE_LADD"
+  "NADD_LE_EXISTS" > "HOLLight.hollight.NADD_LE_EXISTS"
+  "NADD_LE_ANTISYM" > "HOLLight.hollight.NADD_LE_ANTISYM"
+  "NADD_LE_ADD" > "HOLLight.hollight.NADD_LE_ADD"
+  "NADD_LE_0" > "HOLLight.hollight.NADD_LE_0"
+  "NADD_LDISTRIB" > "HOLLight.hollight.NADD_LDISTRIB"
+  "NADD_LBOUND" > "HOLLight.hollight.NADD_LBOUND"
+  "NADD_INV_WELLDEF" > "HOLLight.hollight.NADD_INV_WELLDEF"
+  "NADD_INV_0" > "HOLLight.hollight.NADD_INV_0"
+  "NADD_INV" > "HOLLight.hollight.NADD_INV"
+  "NADD_EQ_TRANS" > "HOLLight.hollight.NADD_EQ_TRANS"
+  "NADD_EQ_SYM" > "HOLLight.hollight.NADD_EQ_SYM"
+  "NADD_EQ_REFL" > "HOLLight.hollight.NADD_EQ_REFL"
+  "NADD_EQ_IMP_LE" > "HOLLight.hollight.NADD_EQ_IMP_LE"
+  "NADD_DIST_LEMMA" > "HOLLight.hollight.NADD_DIST_LEMMA"
+  "NADD_DIST" > "HOLLight.hollight.NADD_DIST"
+  "NADD_COMPLETE" > "HOLLight.hollight.NADD_COMPLETE"
+  "NADD_CAUCHY" > "HOLLight.hollight.NADD_CAUCHY"
+  "NADD_BOUND" > "HOLLight.hollight.NADD_BOUND"
+  "NADD_ARCH_ZERO" > "HOLLight.hollight.NADD_ARCH_ZERO"
+  "NADD_ARCH_MULT" > "HOLLight.hollight.NADD_ARCH_MULT"
+  "NADD_ARCH_LEMMA" > "HOLLight.hollight.NADD_ARCH_LEMMA"
+  "NADD_ARCH" > "HOLLight.hollight.NADD_ARCH"
+  "NADD_ALTMUL" > "HOLLight.hollight.NADD_ALTMUL"
+  "NADD_ADD_WELLDEF" > "HOLLight.hollight.NADD_ADD_WELLDEF"
+  "NADD_ADD_SYM" > "HOLLight.hollight.NADD_ADD_SYM"
+  "NADD_ADD_LID" > "HOLLight.hollight.NADD_ADD_LID"
+  "NADD_ADD_LCANCEL" > "HOLLight.hollight.NADD_ADD_LCANCEL"
+  "NADD_ADD_ASSOC" > "HOLLight.hollight.NADD_ADD_ASSOC"
+  "NADD_ADDITIVE" > "HOLLight.hollight.NADD_ADDITIVE"
+  "NADD_ADD" > "HOLLight.hollight.NADD_ADD"
+  "MULT_SYM" > "Fields.linordered_field_class.sign_simps_40"
+  "MULT_SUC" > "Nat.mult_Suc_right"
+  "MULT_EXP" > "Power.comm_monoid_mult_class.power_mult_distrib"
+  "MULT_EQ_1" > "Nat.nat_mult_eq_1_iff"
+  "MULT_EQ_0" > "Nat.mult_is_0"
+  "MULT_DIV_LE" > "HOLLight.hollight.MULT_DIV_LE"
+  "MULT_CLAUSES" > "HOLLight.hollight.MULT_CLAUSES"
+  "MULT_ASSOC" > "Fields.linordered_field_class.sign_simps_41"
+  "MULT_AC" > "HOLLight.hollight.MULT_AC"
+  "MULT_2" > "Int.semiring_mult_2"
+  "MULT_0" > "Divides.arithmetic_simps_41"
+  "MONO_FORALL" > "Inductive.basic_monos_6"
+  "MONO_EXISTS" > "Inductive.basic_monos_5"
+  "MONO_COND" > "HOLLight.hollight.MONO_COND"
+  "MONO_ALL2" > "List.list_all2_mono"
+  "MONO_ALL" > "HOLLightList.MONO_ALL"
+  "MONOIDAL_REAL_MUL" > "HOLLight.hollight.MONOIDAL_REAL_MUL"
+  "MONOIDAL_REAL_ADD" > "HOLLight.hollight.MONOIDAL_REAL_ADD"
+  "MONOIDAL_MUL" > "HOLLight.hollight.MONOIDAL_MUL"
+  "MONOIDAL_ADD" > "HOLLight.hollight.MONOIDAL_ADD"
+  "MONOIDAL_AC" > "HOLLight.hollight.MONOIDAL_AC"
+  "MOD_UNIQ" > "HOLLight.hollight.MOD_UNIQ"
+  "MOD_MULT_RMOD" > "HOLLight.hollight.MOD_MULT_RMOD"
+  "MOD_MULT_MOD2" > "HOLLight.hollight.MOD_MULT_MOD2"
+  "MOD_MULT_LMOD" > "HOLLight.hollight.MOD_MULT_LMOD"
+  "MOD_MULT_ADD" > "Divides.mod_mult_self3"
+  "MOD_MULT2" > "HOLLight.hollight.MOD_MULT2"
+  "MOD_MOD_REFL" > "HOLLight.hollight.MOD_MOD_REFL"
+  "MOD_MOD" > "HOLLight.hollight.MOD_MOD"
+  "MOD_LT" > "Divides.mod_less"
+  "MOD_LE" > "HOLLight.hollight.MOD_LE"
+  "MOD_EXP_MOD" > "HOLLight.hollight.MOD_EXP_MOD"
+  "MOD_EXISTS" > "HOLLight.hollight.MOD_EXISTS"
+  "MOD_EQ_0" > "HOLLight.hollight.MOD_EQ_0"
+  "MOD_EQ" > "HOLLight.hollight.MOD_EQ"
+  "MOD_ADD_MOD" > "HOLLight.hollight.MOD_ADD_MOD"
+  "MK_REC_INJ" > "HOLLight.hollight.MK_REC_INJ"
+  "MINIMAL" > "HOLLight.hollight.MINIMAL"
+  "MEM_MAP" > "HOLLightList.MEM_MAP"
+  "MEM_FILTER" > "HOLLightList.MEM_FILTER"
+  "MEM_EXISTS_EL" > "HOLLightList.MEM_EXISTS_EL"
+  "MEM_EL" > "List.nth_mem"
+  "MEM_APPEND" > "HOLLightList.MEM_APPEND"
+  "MEMBER_NOT_EMPTY" > "Set.ex_in_conv"
+  "MEASURE_LE" > "HOLLight.hollight.MEASURE_LE"
+  "MATCH_SEQPATTERN" > "HOLLight.hollight.MATCH_SEQPATTERN"
+  "MAP_o" > "List.map.compositionality"
+  "MAP_SND_ZIP" > "List.map_snd_zip"
+  "MAP_ID" > "List.map_ident"
+  "MAP_I" > "List.map.id"
+  "MAP_FST_ZIP" > "List.map_fst_zip"
+  "MAP_EQ_NIL" > "List.map_is_Nil_conv"
+  "MAP_EQ_DEGEN" > "HOLLightList.MAP_EQ_DEGEN"
+  "MAP_EQ_ALL2" > "HOLLightList.MAP_EQ_ALL2"
+  "MAP_EQ" > "HOLLightList.MAP_EQ"
+  "MAP_APPEND" > "List.map_append"
+  "MAP2" > "HOLLightList.MAP2"
+  "LT_TRANS" > "Orderings.order_less_trans"
+  "LT_SUC_LE" > "Nat.le_simps_2"
+  "LT_SUC" > "Nat.Suc_less_eq"
+  "LT_REFL" > "Nat.less_not_refl"
+  "LT_NZ" > "Nat.neq0_conv"
+  "LT_MULT_RCANCEL" > "HOLLight.hollight.LT_MULT_RCANCEL"
+  "LT_MULT_LCANCEL" > "HOLLight.hollight.LT_MULT_LCANCEL"
+  "LT_MULT2" > "HOLLight.hollight.LT_MULT2"
+  "LT_MULT" > "Nat.nat_0_less_mult_iff"
+  "LT_LMULT" > "HOLLight.hollight.LT_LMULT"
+  "LT_LE" > "Nat.nat_less_le"
+  "LT_IMP_LE" > "FunDef.termination_basic_simps_5"
+  "LT_EXP" > "HOLLight.hollight.LT_EXP"
+  "LT_EXISTS" > "HOLLight.hollight.LT_EXISTS"
+  "LT_CASES" > "HOLLight.hollight.LT_CASES"
+  "LT_ANTISYM" > "HOLLight.hollight.LT_ANTISYM"
+  "LT_ADD_RCANCEL" > "Groups.ordered_ab_semigroup_add_imp_le_class.add_less_cancel_right"
+  "LT_ADD_LCANCEL" > "Groups.ordered_ab_semigroup_add_imp_le_class.add_less_cancel_left"
+  "LT_ADDR" > "HOLLight.hollight.LT_ADDR"
+  "LT_ADD2" > "Groups.add_mono_thms_linordered_field_5"
+  "LT_ADD" > "HOLLight.hollight.LT_ADD"
+  "LT_0" > "Nat.zero_less_Suc"
+  "LTE_TRANS" > "Orderings.order_less_le_trans"
+  "LTE_CASES" > "HOLLight.hollight.LTE_CASES"
+  "LTE_ANTISYM" > "HOLLight.hollight.LTE_ANTISYM"
+  "LTE_ADD2" > "Groups.add_mono_thms_linordered_field_3"
+  "LE_TRANS" > "Nat.le_trans"
+  "LE_SUC_LT" > "Nat.Suc_le_eq"
+  "LE_SUC" > "Nat.Suc_le_mono"
+  "LE_SQUARE_REFL" > "Nat.le_square"
+  "LE_REFL" > "Nat.le_refl"
+  "LE_RDIV_EQ" > "HOLLight.hollight.LE_RDIV_EQ"
+  "LE_MULT_RCANCEL" > "HOLLight.hollight.LE_MULT_RCANCEL"
+  "LE_MULT_LCANCEL" > "HOLLight.hollight.LE_MULT_LCANCEL"
+  "LE_MULT2" > "Nat.mult_le_mono"
+  "LE_LT" > "Nat.le_eq_less_or_eq"
+  "LE_LDIV_EQ" > "HOLLight.hollight.LE_LDIV_EQ"
+  "LE_LDIV" > "HOLLight.hollight.LE_LDIV"
+  "LE_EXP" > "HOLLight.hollight.LE_EXP"
+  "LE_EXISTS" > "Nat.le_iff_add"
+  "LE_CASES" > "Nat.nat_le_linear"
+  "LE_C" > "HOLLight.hollight.LE_C"
+  "LE_ANTISYM" > "Orderings.order_class.eq_iff"
+  "LE_ADD_RCANCEL" > "Groups.ordered_ab_semigroup_add_imp_le_class.add_le_cancel_right"
+  "LE_ADD_LCANCEL" > "Groups.ordered_ab_semigroup_add_imp_le_class.add_le_cancel_left"
+  "LE_ADDR" > "Nat.le_add2"
+  "LE_ADD2" > "Groups.add_mono_thms_linordered_semiring_1"
+  "LE_ADD" > "Nat.le_add1"
+  "LE_1" > "HOLLight.hollight.LE_1"
+  "LE_0" > "Nat.le0"
+  "LET_TRANS" > "Orderings.order_le_less_trans"
+  "LET_END_def" > "HOLLight.hollight.LET_END_def"
+  "LET_CASES" > "Orderings.linorder_class.le_less_linear"
+  "LET_ANTISYM" > "HOLLight.hollight.LET_ANTISYM"
+  "LET_ADD2" > "Groups.add_mono_thms_linordered_field_4"
+  "LENGTH_TL" > "HOLLightList.LENGTH_TL"
+  "LENGTH_REPLICATE" > "List.length_replicate"
+  "LENGTH_MAP2" > "HOLLightList.LENGTH_MAP2"
+  "LENGTH_MAP" > "List.length_map"
+  "LENGTH_EQ_NIL" > "List.length_0_conv"
+  "LENGTH_EQ_CONS" > "List.length_Suc_conv"
+  "LENGTH_APPEND" > "List.length_append"
+  "LEFT_SUB_DISTRIB" > "Nat.diff_mult_distrib2"
+  "LEFT_OR_FORALL_THM" > "HOL.all_simps_3"
+  "LEFT_OR_EXISTS_THM" > "HOL.ex_simps_3"
+  "LEFT_OR_DISTRIB" > "Groebner_Basis.dnf_1"
+  "LEFT_IMP_FORALL_THM" > "HOL.ex_simps_5"
+  "LEFT_IMP_EXISTS_THM" > "HOL.all_simps_5"
+  "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_FORALL_THM" > "HOL.all_simps_1"
+  "LEFT_AND_EXISTS_THM" > "HOL.ex_simps_1"
+  "LEFT_ADD_DISTRIB" > "Fields.linordered_field_class.sign_simps_25"
+  "LAST_EL" > "List.last_conv_nth"
+  "LAST_CLAUSES" > "HOLLightList.LAST_CLAUSES"
+  "LAST_APPEND" > "List.last_append"
+  "LAMBDA_UNIQUE" > "HOLLight.hollight.LAMBDA_UNIQUE"
+  "LAMBDA_PAIR_THM" > "HOLLight.hollight.LAMBDA_PAIR_THM"
+  "LAMBDA_ETA" > "HOLLight.hollight.LAMBDA_ETA"
+  "LAMBDA_BETA" > "HOLLight.hollight.LAMBDA_BETA"
+  "I_THM" > "HOL.refl"
+  "I_O_ID" > "HOLLight.hollight.I_O_ID"
+  "ITSET_def" > "HOLLight.hollight.ITSET_def"
+  "ITSET_EQ" > "HOLLight.hollight.ITSET_EQ"
+  "ITLIST_EXTRA" > "HOLLightList.ITLIST_EXTRA"
+  "ITLIST_APPEND" > "List.foldr_append"
+  "ITLIST2" > "HOLLightList.ITLIST2"
+  "ITERATE_UNION_NONZERO" > "HOLLight.hollight.ITERATE_UNION_NONZERO"
+  "ITERATE_UNION_GEN" > "HOLLight.hollight.ITERATE_UNION_GEN"
+  "ITERATE_UNION" > "HOLLight.hollight.ITERATE_UNION"
+  "ITERATE_SUPPORT" > "HOLLight.hollight.ITERATE_SUPPORT"
+  "ITERATE_SUPERSET" > "HOLLight.hollight.ITERATE_SUPERSET"
+  "ITERATE_SING" > "HOLLight.hollight.ITERATE_SING"
+  "ITERATE_RELATED" > "HOLLight.hollight.ITERATE_RELATED"
+  "ITERATE_PAIR" > "HOLLight.hollight.ITERATE_PAIR"
+  "ITERATE_OP_GEN" > "HOLLight.hollight.ITERATE_OP_GEN"
+  "ITERATE_OP" > "HOLLight.hollight.ITERATE_OP"
+  "ITERATE_ITERATE_PRODUCT" > "HOLLight.hollight.ITERATE_ITERATE_PRODUCT"
+  "ITERATE_INJECTION" > "HOLLight.hollight.ITERATE_INJECTION"
+  "ITERATE_INCL_EXCL" > "HOLLight.hollight.ITERATE_INCL_EXCL"
+  "ITERATE_IMAGE_NONZERO" > "HOLLight.hollight.ITERATE_IMAGE_NONZERO"
+  "ITERATE_IMAGE" > "HOLLight.hollight.ITERATE_IMAGE"
+  "ITERATE_EXPAND_CASES" > "HOLLight.hollight.ITERATE_EXPAND_CASES"
+  "ITERATE_EQ_NEUTRAL" > "HOLLight.hollight.ITERATE_EQ_NEUTRAL"
+  "ITERATE_EQ_GENERAL_INVERSES" > "HOLLight.hollight.ITERATE_EQ_GENERAL_INVERSES"
+  "ITERATE_EQ_GENERAL" > "HOLLight.hollight.ITERATE_EQ_GENERAL"
+  "ITERATE_EQ" > "HOLLight.hollight.ITERATE_EQ"
+  "ITERATE_DIFF_GEN" > "HOLLight.hollight.ITERATE_DIFF_GEN"
+  "ITERATE_DIFF" > "HOLLight.hollight.ITERATE_DIFF"
+  "ITERATE_DELTA" > "HOLLight.hollight.ITERATE_DELTA"
+  "ITERATE_DELETE" > "HOLLight.hollight.ITERATE_DELETE"
+  "ITERATE_CLOSED" > "HOLLight.hollight.ITERATE_CLOSED"
+  "ITERATE_CLAUSES_NUMSEG" > "HOLLight.hollight.ITERATE_CLAUSES_NUMSEG"
+  "ITERATE_CLAUSES_GEN" > "HOLLight.hollight.ITERATE_CLAUSES_GEN"
+  "ITERATE_CLAUSES" > "HOLLight.hollight.ITERATE_CLAUSES"
+  "ITERATE_CASES" > "HOLLight.hollight.ITERATE_CASES"
+  "ITERATE_BIJECTION" > "HOLLight.hollight.ITERATE_BIJECTION"
+  "ISO_def" > "HOLLight.hollight.ISO_def"
+  "ISO_USAGE" > "HOLLight.hollight.ISO_USAGE"
+  "ISO_REFL" > "HOLLight.hollight.ISO_REFL"
+  "ISO_FUN" > "HOLLight.hollight.ISO_FUN"
+  "IN_UNIV" > "Set.UNIV_I"
+  "IN_UNIONS" > "HOLLight.hollight.IN_UNIONS"
+  "IN_UNION" > "Complete_Lattices.mem_simps_3"
+  "IN_SUPPORT" > "HOLLight.hollight.IN_SUPPORT"
+  "IN_SING" > "Set.singleton_iff"
+  "IN_SET_OF_LIST" > "HOLLightList.IN_SET_OF_LIST"
+  "IN_REST" > "HOLLight.hollight.IN_REST"
+  "IN_NUMSEG_0" > "HOLLight.hollight.IN_NUMSEG_0"
+  "IN_NUMSEG" > "SetInterval.ord_class.atLeastAtMost_iff"
+  "IN_INTERS" > "HOLLight.hollight.IN_INTERS"
+  "IN_INTER" > "Complete_Lattices.mem_simps_4"
+  "IN_INSERT" > "Complete_Lattices.mem_simps_1"
+  "IN_IMAGE" > "HOLLight.hollight.IN_IMAGE"
+  "IN_ELIM_THM" > "HOLLight.hollight.IN_ELIM_THM"
+  "IN_ELIM_PAIR_THM" > "HOLLight.hollight.IN_ELIM_PAIR_THM"
+  "IN_DISJOINT" > "HOLLight.hollight.IN_DISJOINT"
+  "IN_DIFF" > "Complete_Lattices.mem_simps_6"
+  "IN_DELETE_EQ" > "HOLLight.hollight.IN_DELETE_EQ"
+  "IN_DELETE" > "HOLLight.hollight.IN_DELETE"
+  "IN_CROSS" > "HOLLight.hollight.IN_CROSS"
+  "INT_WOP" > "HOLLight.hollight.INT_WOP"
+  "INT_POW" > "HOLLight.hollight.INT_POW"
+  "INT_OF_NUM_OF_INT" > "HOLLight.hollight.INT_OF_NUM_OF_INT"
+  "INT_LT_DISCRETE" > "HOLLight.hollight.INT_LT_DISCRETE"
+  "INT_LT" > "HOLLight.hollight.INT_LT"
+  "INT_INTEGRAL" > "HOLLight.hollight.INT_INTEGRAL"
+  "INT_IMAGE" > "HOLLight.hollight.INT_IMAGE"
+  "INT_GT_DISCRETE" > "HOLLight.hollight.INT_GT_DISCRETE"
+  "INT_GT" > "HOLLight.hollight.INT_GT"
+  "INT_GE" > "HOLLight.hollight.INT_GE"
+  "INT_GCD_EXISTS_POS" > "HOLLight.hollight.INT_GCD_EXISTS_POS"
+  "INT_GCD_EXISTS" > "HOLLight.hollight.INT_GCD_EXISTS"
+  "INT_FORALL_POS" > "HOLLight.hollight.INT_FORALL_POS"
+  "INT_FORALL_ABS" > "HOLLight.hollight.INT_FORALL_ABS"
+  "INT_EXISTS_POS" > "HOLLight.hollight.INT_EXISTS_POS"
+  "INT_EXISTS_ABS" > "HOLLight.hollight.INT_EXISTS_ABS"
+  "INT_DIVMOD_UNIQ" > "HOLLight.hollight.INT_DIVMOD_UNIQ"
+  "INT_DIVMOD_EXIST_0" > "HOLLight.hollight.INT_DIVMOD_EXIST_0"
+  "INT_DIVISION" > "HOLLight.hollight.INT_DIVISION"
+  "INT_ARCH" > "HOLLight.hollight.INT_ARCH"
+  "INT_ABS_MUL_1" > "HOLLight.hollight.INT_ABS_MUL_1"
+  "INT_ABS" > "HOLLight.hollight.INT_ABS"
+  "INTER_UNIV" > "HOLLight.hollight.INTER_UNIV"
+  "INTER_UNIONS" > "HOLLight.hollight.INTER_UNIONS"
+  "INTER_SUBSET" > "HOLLight.hollight.INTER_SUBSET"
+  "INTER_OVER_UNION" > "Lattices.distrib_lattice_class.distrib_1"
+  "INTER_IDEMPOT" > "Big_Operators.lattice_class.Inf_fin.idem"
+  "INTER_EMPTY" > "HOLLight.hollight.INTER_EMPTY"
+  "INTER_COMM" > "Lattices.lattice_class.inf_sup_aci_1"
+  "INTER_ASSOC" > "Lattices.lattice_class.inf_sup_aci_2"
+  "INTER_ACI" > "HOLLight.hollight.INTER_ACI"
+  "INTERS_UNIONS" > "HOLLight.hollight.INTERS_UNIONS"
+  "INTERS_INSERT" > "Complete_Lattices.Inter_insert"
+  "INTERS_IMAGE" > "HOLLight.hollight.INTERS_IMAGE"
+  "INTERS_GSPEC" > "HOLLight.hollight.INTERS_GSPEC"
+  "INTERS_2" > "Complete_Lattices.Int_eq_Inter"
+  "INTERS_1" > "Complete_Lattices.complete_lattice_class.Inf_singleton"
+  "INTERS_0" > "Complete_Lattices.Inter_empty"
+  "INSERT_UNIV" > "HOLLight.hollight.INSERT_UNIV"
+  "INSERT_UNION_EQ" > "Set.Un_insert_left"
+  "INSERT_UNION" > "HOLLight.hollight.INSERT_UNION"
+  "INSERT_SUBSET" > "Set.insert_subset"
+  "INSERT_INTER" > "Set.Int_insert_left"
+  "INSERT_INSERT" > "Set.insert_absorb2"
+  "INSERT_DIFF" > "Set.insert_Diff_if"
+  "INSERT_DELETE" > "Set.insert_Diff"
+  "INSERT_COMM" > "Set.insert_commute"
+  "INSERT_AC" > "HOLLight.hollight.INSERT_AC"
+  "INSERT" > "HOLLight.hollight.INSERT"
+  "INJ_def" > "HOLLight.hollight.INJ_def"
+  "INJ_INVERSE2" > "HOLLight.hollight.INJ_INVERSE2"
+  "INJP_def" > "HOLLight.hollight.INJP_def"
+  "INJP_INJ" > "HOLLight.hollight.INJP_INJ"
+  "INJN_def" > "HOLLight.hollight.INJN_def"
+  "INJN_INJ" > "HOLLight.hollight.INJN_INJ"
+  "INJF_def" > "HOLLight.hollight.INJF_def"
+  "INJF_INJ" > "HOLLight.hollight.INJF_INJ"
+  "INJECTIVE_ON_LEFT_INVERSE" > "HOLLight.hollight.INJECTIVE_ON_LEFT_INVERSE"
+  "INJECTIVE_ON_IMAGE" > "HOLLight.hollight.INJECTIVE_ON_IMAGE"
+  "INJECTIVE_MAP" > "HOLLightList.INJECTIVE_MAP"
+  "INJECTIVE_LEFT_INVERSE" > "HOLLight.hollight.INJECTIVE_LEFT_INVERSE"
+  "INJECTIVE_IMAGE" > "HOLLight.hollight.INJECTIVE_IMAGE"
+  "INJA_def" > "HOLLight.hollight.INJA_def"
+  "INJA_INJ" > "HOLLight.hollight.INJA_INJ"
+  "INFINITE_NONEMPTY" > "Infinite_Set.infinite_imp_nonempty"
+  "INFINITE_IMAGE_INJ" > "HOLLight.hollight.INFINITE_IMAGE_INJ"
+  "INFINITE_DIFF_FINITE" > "Infinite_Set.Diff_infinite_finite"
+  "IND_SUC_def" > "HOLLight.hollight.IND_SUC_def"
+  "IND_SUC_0_EXISTS" > "HOLLight.hollight.IND_SUC_0_EXISTS"
+  "IND_0_def" > "HOLLight.hollight.IND_0_def"
+  "IMP_EQ_CLAUSE" > "HOLLight.hollight.IMP_EQ_CLAUSE"
+  "IMP_CONJ_ALT" > "HOLLight.hollight.IMP_CONJ_ALT"
+  "IMP_CONJ" > "HOL.imp_conjL"
+  "IMP_CLAUSES" > "HOLLight.hollight.IMP_CLAUSES"
+  "IMAGE_o" > "Fun.image_compose"
+  "IMAGE_UNIONS" > "HOLLight.hollight.IMAGE_UNIONS"
+  "IMAGE_UNION" > "Set.image_Un"
+  "IMAGE_SUBSET" > "Set.image_mono"
+  "IMAGE_INTER_INJ" > "HOLLight.hollight.IMAGE_INTER_INJ"
+  "IMAGE_INJECTIVE_IMAGE_OF_SUBSET" > "HOLLight.hollight.IMAGE_INJECTIVE_IMAGE_OF_SUBSET"
+  "IMAGE_IMP_INJECTIVE_GEN" > "HOLLight.hollight.IMAGE_IMP_INJECTIVE_GEN"
+  "IMAGE_IMP_INJECTIVE" > "HOLLight.hollight.IMAGE_IMP_INJECTIVE"
+  "IMAGE_ID" > "Set.image_ident"
+  "IMAGE_I" > "Fun.image_id"
+  "IMAGE_EQ_EMPTY" > "Set.image_is_empty"
+  "IMAGE_DIFF_INJ" > "HOLLight.hollight.IMAGE_DIFF_INJ"
+  "IMAGE_DELETE_INJ" > "HOLLight.hollight.IMAGE_DELETE_INJ"
+  "IMAGE_CONST" > "Set.image_constant_conv"
+  "IMAGE_CLAUSES" > "HOLLight.hollight.IMAGE_CLAUSES"
+  "HREAL_MUL_RZERO" > "HOLLight.hollight.HREAL_MUL_RZERO"
+  "HREAL_MUL_LZERO" > "HOLLight.hollight.HREAL_MUL_LZERO"
+  "HREAL_LE_MUL_RCANCEL_IMP" > "HOLLight.hollight.HREAL_LE_MUL_RCANCEL_IMP"
+  "HREAL_LE_EXISTS_DEF" > "HOLLight.hollight.HREAL_LE_EXISTS_DEF"
+  "HREAL_LE_ADD_RCANCEL" > "HOLLight.hollight.HREAL_LE_ADD_RCANCEL"
+  "HREAL_LE_ADD_LCANCEL" > "HOLLight.hollight.HREAL_LE_ADD_LCANCEL"
+  "HREAL_LE_ADD2" > "HOLLight.hollight.HREAL_LE_ADD2"
+  "HREAL_EQ_ADD_RCANCEL" > "HOLLight.hollight.HREAL_EQ_ADD_RCANCEL"
+  "HREAL_EQ_ADD_LCANCEL" > "HOLLight.hollight.HREAL_EQ_ADD_LCANCEL"
+  "HREAL_ADD_RID" > "HOLLight.hollight.HREAL_ADD_RID"
+  "HREAL_ADD_RDISTRIB" > "HOLLight.hollight.HREAL_ADD_RDISTRIB"
+  "HREAL_ADD_AC" > "HOLLight.hollight.HREAL_ADD_AC"
+  "HD_APPEND" > "List.hd_append"
+  "HAS_SIZE_def" > "HOLLight.hollight.HAS_SIZE_def"
+  "HAS_SIZE_UNIONS" > "HOLLight.hollight.HAS_SIZE_UNIONS"
+  "HAS_SIZE_UNION" > "HOLLight.hollight.HAS_SIZE_UNION"
+  "HAS_SIZE_SUC" > "HOLLight.hollight.HAS_SIZE_SUC"
+  "HAS_SIZE_PRODUCT_DEPENDENT" > "HOLLight.hollight.HAS_SIZE_PRODUCT_DEPENDENT"
+  "HAS_SIZE_PRODUCT" > "HOLLight.hollight.HAS_SIZE_PRODUCT"
+  "HAS_SIZE_POWERSET" > "HOLLight.hollight.HAS_SIZE_POWERSET"
+  "HAS_SIZE_NUMSEG_LT" > "HOLLight.hollight.HAS_SIZE_NUMSEG_LT"
+  "HAS_SIZE_NUMSEG_LE" > "HOLLight.hollight.HAS_SIZE_NUMSEG_LE"
+  "HAS_SIZE_NUMSEG_1" > "HOLLight.hollight.HAS_SIZE_NUMSEG_1"
+  "HAS_SIZE_NUMSEG" > "HOLLight.hollight.HAS_SIZE_NUMSEG"
+  "HAS_SIZE_INDEX" > "HOLLight.hollight.HAS_SIZE_INDEX"
+  "HAS_SIZE_IMAGE_INJ_EQ" > "HOLLight.hollight.HAS_SIZE_IMAGE_INJ_EQ"
+  "HAS_SIZE_IMAGE_INJ" > "HOLLight.hollight.HAS_SIZE_IMAGE_INJ"
+  "HAS_SIZE_FUNSPACE" > "HOLLight.hollight.HAS_SIZE_FUNSPACE"
+  "HAS_SIZE_FINITE_IMAGE" > "HOLLight.hollight.HAS_SIZE_FINITE_IMAGE"
+  "HAS_SIZE_DIFF" > "HOLLight.hollight.HAS_SIZE_DIFF"
+  "HAS_SIZE_CROSS" > "HOLLight.hollight.HAS_SIZE_CROSS"
+  "HAS_SIZE_CLAUSES" > "HOLLight.hollight.HAS_SIZE_CLAUSES"
+  "HAS_SIZE_CARD" > "HOLLight.hollight.HAS_SIZE_CARD"
+  "HAS_SIZE_1" > "HOLLight.hollight.HAS_SIZE_1"
+  "HAS_SIZE_0" > "HOLLight.hollight.HAS_SIZE_0"
+  "GE_C" > "HOLLight.hollight.GE_C"
+  "FUN_IN_IMAGE" > "Set.imageI"
+  "FUN_EQ_THM" > "HOL.fun_eq_iff"
+  "FUNCTION_FACTORS_RIGHT" > "HOLLight.hollight.FUNCTION_FACTORS_RIGHT"
+  "FUNCTION_FACTORS_LEFT" > "HOLLight.hollight.FUNCTION_FACTORS_LEFT"
+  "FST" > "Product_Type.fst_conv"
+  "FORALL_UNWIND_THM2" > "HOL.simp_thms_41"
+  "FORALL_UNWIND_THM1" > "HOL.simp_thms_42"
+  "FORALL_UNCURRY" > "HOLLight.hollight.FORALL_UNCURRY"
+  "FORALL_TRIPLED_THM" > "HOLLight.hollight.FORALL_TRIPLED_THM"
+  "FORALL_SUBSET_IMAGE" > "HOLLight.hollight.FORALL_SUBSET_IMAGE"
+  "FORALL_SIMP" > "HOL.simp_thms_35"
+  "FORALL_PAIR_THM" > "Product_Type.split_paired_All"
+  "FORALL_PAIRED_THM" > "HOLLight.hollight.FORALL_PAIRED_THM"
+  "FORALL_NOT_THM" > "HOL.not_ex"
+  "FORALL_IN_UNIONS" > "HOLLight.hollight.FORALL_IN_UNIONS"
+  "FORALL_IN_INSERT" > "HOLLight.hollight.FORALL_IN_INSERT"
+  "FORALL_IN_IMAGE" > "HOLLight.hollight.FORALL_IN_IMAGE"
+  "FORALL_IN_GSPEC" > "HOLLight.hollight.FORALL_IN_GSPEC"
+  "FORALL_IN_CLAUSES" > "HOLLight.hollight.FORALL_IN_CLAUSES"
+  "FORALL_FINITE_INDEX" > "HOLLight.hollight.FORALL_FINITE_INDEX"
+  "FORALL_BOOL_THM" > "Set.all_bool_eq"
+  "FORALL_AND_THM" > "HOL.all_conj_distrib"
+  "FORALL_ALL" > "HOLLightList.FORALL_ALL"
+  "FNIL_def" > "HOLLight.hollight.FNIL_def"
+  "FINREC_def" > "HOLLight.hollight.FINREC_def"
+  "FINREC_UNIQUE_LEMMA" > "HOLLight.hollight.FINREC_UNIQUE_LEMMA"
+  "FINREC_SUC_LEMMA" > "HOLLight.hollight.FINREC_SUC_LEMMA"
+  "FINREC_FUN_LEMMA" > "HOLLight.hollight.FINREC_FUN_LEMMA"
+  "FINREC_FUN" > "HOLLight.hollight.FINREC_FUN"
+  "FINREC_EXISTS_LEMMA" > "HOLLight.hollight.FINREC_EXISTS_LEMMA"
+  "FINREC_1_LEMMA" > "HOLLight.hollight.FINREC_1_LEMMA"
+  "FINITE_UNION_IMP" > "Finite_Set.finite_UnI"
+  "FINITE_UNIONS" > "HOLLight.hollight.FINITE_UNIONS"
+  "FINITE_UNION" > "Finite_Set.finite_Un"
+  "FINITE_SUPPORT_DELTA" > "HOLLight.hollight.FINITE_SUPPORT_DELTA"
+  "FINITE_SUPPORT" > "HOLLight.hollight.FINITE_SUPPORT"
+  "FINITE_SUM_IMAGE" > "HOLLight.hollight.FINITE_SUM_IMAGE"
+  "FINITE_SUBSET_IMAGE_IMP" > "HOLLight.hollight.FINITE_SUBSET_IMAGE_IMP"
+  "FINITE_SUBSET_IMAGE" > "HOLLight.hollight.FINITE_SUBSET_IMAGE"
+  "FINITE_SUBSET" > "Finite_Set.finite_subset"
+  "FINITE_SING" > "HOLLight.hollight.FINITE_SING"
+  "FINITE_RESTRICT" > "HOLLight.hollight.FINITE_RESTRICT"
+  "FINITE_RECURSION_DELETE" > "HOLLight.hollight.FINITE_RECURSION_DELETE"
+  "FINITE_RECURSION" > "HOLLight.hollight.FINITE_RECURSION"
+  "FINITE_REAL_INTERVAL" > "HOLLight.hollight.FINITE_REAL_INTERVAL"
+  "FINITE_PRODUCT_DEPENDENT" > "HOLLight.hollight.FINITE_PRODUCT_DEPENDENT"
+  "FINITE_PRODUCT" > "HOLLight.hollight.FINITE_PRODUCT"
+  "FINITE_POWERSET" > "HOLLight.hollight.FINITE_POWERSET"
+  "FINITE_NUMSEG_LT" > "HOLLight.hollight.FINITE_NUMSEG_LT"
+  "FINITE_NUMSEG_LE" > "HOLLight.hollight.FINITE_NUMSEG_LE"
+  "FINITE_NUMSEG" > "SetInterval.finite_atLeastAtMost"
+  "FINITE_INTSEG" > "HOLLight.hollight.FINITE_INTSEG"
+  "FINITE_INTER" > "Finite_Set.finite_Int"
+  "FINITE_INSERT" > "Finite_Set.finite_insert"
+  "FINITE_INDUCT_STRONG" > "Finite_Set.finite_induct"
+  "FINITE_INDUCT_DELETE" > "HOLLight.hollight.FINITE_INDUCT_DELETE"
+  "FINITE_INDEX_WORKS" > "HOLLight.hollight.FINITE_INDEX_WORKS"
+  "FINITE_INDEX_NUMSEG" > "HOLLight.hollight.FINITE_INDEX_NUMSEG"
+  "FINITE_INDEX_NUMBERS" > "HOLLight.hollight.FINITE_INDEX_NUMBERS"
+  "FINITE_INDEX_INRANGE" > "HOLLight.hollight.FINITE_INDEX_INRANGE"
+  "FINITE_INDEX_INJ" > "HOLLight.hollight.FINITE_INDEX_INJ"
+  "FINITE_IMAGE_INJ_GENERAL" > "HOLLight.hollight.FINITE_IMAGE_INJ_GENERAL"
+  "FINITE_IMAGE_INJ_EQ" > "HOLLight.hollight.FINITE_IMAGE_INJ_EQ"
+  "FINITE_IMAGE_INJ" > "HOLLight.hollight.FINITE_IMAGE_INJ"
+  "FINITE_IMAGE_IMAGE" > "HOLLight.hollight.FINITE_IMAGE_IMAGE"
+  "FINITE_IMAGE_EXPAND" > "HOLLight.hollight.FINITE_IMAGE_EXPAND"
+  "FINITE_IMAGE" > "Finite_Set.finite_imageI"
+  "FINITE_HAS_SIZE" > "HOLLight.hollight.FINITE_HAS_SIZE"
+  "FINITE_FUNSPACE" > "HOLLight.hollight.FINITE_FUNSPACE"
+  "FINITE_FINITE_UNIONS" > "HOLLight.hollight.FINITE_FINITE_UNIONS"
+  "FINITE_FINITE_PREIMAGE_GENERAL" > "HOLLight.hollight.FINITE_FINITE_PREIMAGE_GENERAL"
+  "FINITE_FINITE_PREIMAGE" > "HOLLight.hollight.FINITE_FINITE_PREIMAGE"
+  "FINITE_FINITE_IMAGE" > "HOLLight.hollight.FINITE_FINITE_IMAGE"
+  "FINITE_EMPTY" > "Finite_Set.finite.emptyI"
+  "FINITE_DIFF" > "Finite_Set.finite_Diff"
+  "FINITE_DELETE_IMP" > "HOLLight.hollight.FINITE_DELETE_IMP"
+  "FINITE_DELETE" > "HOLLight.hollight.FINITE_DELETE"
+  "FINITE_CROSS" > "HOLLight.hollight.FINITE_CROSS"
+  "FINITE_CART" > "HOLLight.hollight.FINITE_CART"
+  "FILTER_MAP" > "List.filter_map"
+  "FILTER_APPEND" > "List.filter_append"
+  "FCONS_def" > "HOLLight.hollight.FCONS_def"
+  "FCONS_UNDO" > "HOLLight.hollight.FCONS_UNDO"
+  "FACT_NZ" > "Fact.fact_nonzero_nat"
+  "FACT_MONO" > "Fact.fact_mono_nat"
+  "FACT_LT" > "Fact.fact_gt_zero_nat"
+  "FACT_LE" > "Fact.fact_ge_one_nat"
+  "EX_MEM" > "HOLLightList.EX_MEM"
+  "EX_IMP" > "HOLLightList.EX_IMP"
+  "EXTENSION" > "Set.set_eq_iff"
+  "EXP_ZERO" > "Power.power_0_left"
+  "EXP_ONE" > "Power.monoid_mult_class.power_one"
+  "EXP_MULT" > "Power.monoid_mult_class.power_mult"
+  "EXP_MONO_LT_IMP" > "HOLLight.hollight.EXP_MONO_LT_IMP"
+  "EXP_MONO_LT" > "HOLLight.hollight.EXP_MONO_LT"
+  "EXP_MONO_LE_IMP" > "HOLLight.hollight.EXP_MONO_LE_IMP"
+  "EXP_MONO_LE" > "HOLLight.hollight.EXP_MONO_LE"
+  "EXP_MONO_EQ" > "HOLLight.hollight.EXP_MONO_EQ"
+  "EXP_LT_0" > "HOLLight.hollight.EXP_LT_0"
+  "EXP_EQ_1" > "HOLLight.hollight.EXP_EQ_1"
+  "EXP_EQ_0" > "Power.power_eq_0_iff"
+  "EXP_ADD" > "Power.monoid_mult_class.power_add"
+  "EXP_2" > "Nat_Numeral.monoid_mult_class.power2_eq_square"
+  "EXP_1" > "Power.monoid_mult_class.power_one_right"
+  "EXISTS_UNIQUE_THM" > "HOLLightCompat.EXISTS_UNIQUE_THM"
+  "EXISTS_UNIQUE_REFL" > "HOL.ex1_eq_1"
+  "EXISTS_UNIQUE_ALT" > "HOLLight.hollight.EXISTS_UNIQUE_ALT"
+  "EXISTS_UNIQUE" > "HOL.Ex1_def"
+  "EXISTS_UNCURRY" > "HOLLight.hollight.EXISTS_UNCURRY"
+  "EXISTS_TRIPLED_THM" > "HOLLight.hollight.EXISTS_TRIPLED_THM"
+  "EXISTS_THM" > "HOL4Setup.EXISTS_DEF"
+  "EXISTS_SUBSET_IMAGE" > "HOLLight.hollight.EXISTS_SUBSET_IMAGE"
+  "EXISTS_SIMP" > "HOL.simp_thms_36"
+  "EXISTS_REFL" > "HOL.simp_thms_37"
+  "EXISTS_PAIR_THM" > "Product_Type.split_paired_Ex"
+  "EXISTS_PAIRED_THM" > "HOLLight.hollight.EXISTS_PAIRED_THM"
+  "EXISTS_OR_THM" > "HOL.ex_disj_distrib"
+  "EXISTS_ONE_REP" > "HOLLight.hollight.EXISTS_ONE_REP"
+  "EXISTS_NOT_THM" > "HOL.not_all"
+  "EXISTS_IN_UNIONS" > "HOLLight.hollight.EXISTS_IN_UNIONS"
+  "EXISTS_IN_INSERT" > "HOLLight.hollight.EXISTS_IN_INSERT"
+  "EXISTS_IN_IMAGE" > "HOLLight.hollight.EXISTS_IN_IMAGE"
+  "EXISTS_IN_GSPEC" > "HOLLight.hollight.EXISTS_IN_GSPEC"
+  "EXISTS_IN_CLAUSES" > "HOLLight.hollight.EXISTS_IN_CLAUSES"
+  "EXISTS_FINITE_SUBSET_IMAGE" > "HOLLight.hollight.EXISTS_FINITE_SUBSET_IMAGE"
+  "EXISTS_EX" > "HOLLightList.EXISTS_EX"
+  "EXISTS_BOOL_THM" > "Set.ex_bool_eq"
+  "EXCLUDED_MIDDLE" > "HOLLight.hollight.EXCLUDED_MIDDLE"
+  "EVEN_SUB" > "HOLLight.hollight.EVEN_SUB"
+  "EVEN_OR_ODD" > "HOLLight.hollight.EVEN_OR_ODD"
+  "EVEN_ODD_DECOMPOSITION" > "HOLLight.hollight.EVEN_ODD_DECOMPOSITION"
+  "EVEN_MULT" > "Parity.even_product_nat"
+  "EVEN_MOD" > "HOLLight.hollight.EVEN_MOD"
+  "EVEN_EXP" > "HOLLight.hollight.EVEN_EXP"
+  "EVEN_EXISTS_LEMMA" > "HOLLight.hollight.EVEN_EXISTS_LEMMA"
+  "EVEN_EXISTS" > "Parity.even_mult_two_ex"
+  "EVEN_DOUBLE" > "HOLLight.hollight.EVEN_DOUBLE"
+  "EVEN_AND_ODD" > "HOLLight.hollight.EVEN_AND_ODD"
+  "EVEN_ADD" > "Parity.even_add"
+  "EQ_UNIV" > "HOLLight.hollight.EQ_UNIV"
+  "EQ_TRANS" > "HOL.trans"
+  "EQ_SYM_EQ" > "HOL.eq_ac_1"
+  "EQ_SYM" > "HOL.eq_reflection"
+  "EQ_REFL" > "HOL.refl"
+  "EQ_MULT_RCANCEL" > "Nat.mult_cancel2"
+  "EQ_MULT_LCANCEL" > "Numeral_Simprocs.nat_mult_eq_cancel_disj"
+  "EQ_IMP_LE" > "Nat.eq_imp_le"
+  "EQ_EXT" > "HOL.eq_reflection"
+  "EQ_EXP" > "HOLLight.hollight.EQ_EXP"
+  "EQ_CLAUSES" > "HOLLight.hollight.EQ_CLAUSES"
+  "EQ_ADD_RCANCEL_0" > "HOLLight.hollight.EQ_ADD_RCANCEL_0"
+  "EQ_ADD_RCANCEL" > "Groups.cancel_semigroup_add_class.add_right_cancel"
+  "EQ_ADD_LCANCEL_0" > "HOLLight.hollight.EQ_ADD_LCANCEL_0"
+  "EQ_ADD_LCANCEL" > "Groups.cancel_semigroup_add_class.add_left_cancel"
+  "EMPTY_UNIONS" > "HOLLight.hollight.EMPTY_UNIONS"
+  "EMPTY_UNION" > "Lattices.bounded_lattice_bot_class.sup_eq_bot_iff"
+  "EMPTY_SUBSET" > "Orderings.bot_class.bot_least"
+  "EMPTY_NOT_UNIV" > "HOLLight.hollight.EMPTY_NOT_UNIV"
+  "EMPTY_GSPEC" > "HOLLight.hollight.EMPTY_GSPEC"
+  "EMPTY_DIFF" > "Set.empty_Diff"
+  "EMPTY_DELETE" > "HOLLight.hollight.EMPTY_DELETE"
+  "EL_CONS" > "List.nth_Cons'"
+  "EL_APPEND" > "List.nth_append"
+  "DIV_UNIQ" > "HOLLight.hollight.DIV_UNIQ"
+  "DIV_REFL" > "Divides.semiring_div_class.div_self"
+  "DIV_MUL_LE" > "HOLLight.hollight.DIV_MUL_LE"
+  "DIV_MULT2" > "HOLLight.hollight.DIV_MULT2"
+  "DIV_MONO_LT" > "HOLLight.hollight.DIV_MONO_LT"
+  "DIV_MONO2" > "HOLLight.hollight.DIV_MONO2"
+  "DIV_MONO" > "HOLLight.hollight.DIV_MONO"
+  "DIV_MOD" > "HOLLight.hollight.DIV_MOD"
+  "DIV_LT" > "Divides.div_less"
+  "DIV_LE_EXCLUSION" > "HOLLight.hollight.DIV_LE_EXCLUSION"
+  "DIV_LE" > "HOLLight.hollight.DIV_LE"
+  "DIV_EQ_EXCLUSION" > "HOLLight.hollight.DIV_EQ_EXCLUSION"
+  "DIV_EQ_0" > "HOLLight.hollight.DIV_EQ_0"
+  "DIV_DIV" > "HOLLight.hollight.DIV_DIV"
+  "DIV_ADD_MOD" > "HOLLight.hollight.DIV_ADD_MOD"
+  "DIVMOD_UNIQ_LEMMA" > "HOLLight.hollight.DIVMOD_UNIQ_LEMMA"
+  "DIVMOD_UNIQ" > "HOLLight.hollight.DIVMOD_UNIQ"
+  "DIVMOD_EXIST_0" > "HOLLight.hollight.DIVMOD_EXIST_0"
+  "DIVMOD_EXIST" > "HOLLight.hollight.DIVMOD_EXIST"
+  "DIVMOD_ELIM_THM" > "HOLLight.hollight.DIVMOD_ELIM_THM"
+  "DIVISION" > "HOLLight.hollight.DIVISION"
+  "DIST_TRIANGLE_LE" > "HOLLight.hollight.DIST_TRIANGLE_LE"
+  "DIST_TRIANGLES_LE" > "HOLLight.hollight.DIST_TRIANGLES_LE"
+  "DIST_SYM" > "HOLLight.hollight.DIST_SYM"
+  "DIST_RZERO" > "HOLLight.hollight.DIST_RZERO"
+  "DIST_RMUL" > "HOLLight.hollight.DIST_RMUL"
+  "DIST_REFL" > "HOLLight.hollight.DIST_REFL"
+  "DIST_RADD_0" > "HOLLight.hollight.DIST_RADD_0"
+  "DIST_RADD" > "HOLLight.hollight.DIST_RADD"
+  "DIST_LZERO" > "HOLLight.hollight.DIST_LZERO"
+  "DIST_LMUL" > "HOLLight.hollight.DIST_LMUL"
+  "DIST_LE_CASES" > "HOLLight.hollight.DIST_LE_CASES"
+  "DIST_LADD_0" > "HOLLight.hollight.DIST_LADD_0"
+  "DIST_LADD" > "HOLLight.hollight.DIST_LADD"
+  "DIST_EQ_0" > "HOLLight.hollight.DIST_EQ_0"
+  "DIST_ELIM_THM" > "HOLLight.hollight.DIST_ELIM_THM"
+  "DISJ_SYM" > "Groebner_Basis.dnf_4"
+  "DISJ_ASSOC" > "HOL.disj_ac_3"
+  "DISJ_ACI" > "HOLLight.hollight.DISJ_ACI"
+  "DISJOINT_UNION" > "HOLLight.hollight.DISJOINT_UNION"
+  "DISJOINT_SYM" > "HOLLight.hollight.DISJOINT_SYM"
+  "DISJOINT_NUMSEG" > "HOLLight.hollight.DISJOINT_NUMSEG"
+  "DISJOINT_INSERT" > "HOLLight.hollight.DISJOINT_INSERT"
+  "DISJOINT_EMPTY_REFL" > "HOLLight.hollight.DISJOINT_EMPTY_REFL"
+  "DISJOINT_EMPTY" > "HOLLight.hollight.DISJOINT_EMPTY"
+  "DISJOINT_DELETE_SYM" > "HOLLight.hollight.DISJOINT_DELETE_SYM"
+  "DIMINDEX_UNIV" > "HOLLight.hollight.DIMINDEX_UNIV"
+  "DIMINDEX_UNIQUE" > "HOLLight.hollight.DIMINDEX_UNIQUE"
+  "DIMINDEX_NONZERO" > "HOLLight.hollight.DIMINDEX_NONZERO"
+  "DIMINDEX_GE_1" > "HOLLight.hollight.DIMINDEX_GE_1"
+  "DIMINDEX_FINITE_IMAGE" > "HOLLight.hollight.DIMINDEX_FINITE_IMAGE"
+  "DIFF_UNIV" > "Set.Diff_UNIV"
+  "DIFF_INTERS" > "HOLLight.hollight.DIFF_INTERS"
+  "DIFF_INSERT" > "Set.Diff_insert2"
+  "DIFF_EQ_EMPTY" > "Set.Diff_cancel"
+  "DIFF_EMPTY" > "Set.Diff_empty"
+  "DIFF_DIFF" > "Set.Diff_idemp"
+  "DEST_REC_INJ" > "HOLLight.hollight.recspace._dest_rec_inject"
+  "DELETE_SUBSET" > "HOLLight.hollight.DELETE_SUBSET"
+  "DELETE_NON_ELEMENT" > "HOLLight.hollight.DELETE_NON_ELEMENT"
+  "DELETE_INTER" > "HOLLight.hollight.DELETE_INTER"
+  "DELETE_INSERT" > "HOLLight.hollight.DELETE_INSERT"
+  "DELETE_DELETE" > "HOLLight.hollight.DELETE_DELETE"
+  "DELETE_COMM" > "HOLLight.hollight.DELETE_COMM"
+  "DEF_~" > "Groebner_Basis.bool_simps_19"
+  "DEF_vector" > "HOLLight.hollight.DEF_vector"
+  "DEF_treal_of_num" > "HOLLight.hollight.DEF_treal_of_num"
+  "DEF_treal_neg" > "HOLLight.hollight.DEF_treal_neg"
+  "DEF_treal_mul" > "HOLLight.hollight.DEF_treal_mul"
+  "DEF_treal_le" > "HOLLight.hollight.DEF_treal_le"
+  "DEF_treal_inv" > "HOLLight.hollight.DEF_treal_inv"
+  "DEF_treal_eq" > "HOLLight.hollight.DEF_treal_eq"
+  "DEF_treal_add" > "HOLLight.hollight.DEF_treal_add"
+  "DEF_tailadmissible" > "HOLLight.hollight.DEF_tailadmissible"
+  "DEF_support" > "HOLLight.hollight.DEF_support"
+  "DEF_superadmissible" > "HOLLight.hollight.DEF_superadmissible"
+  "DEF_sum" > "HOLLight.hollight.DEF_sum"
+  "DEF_sndcart" > "HOLLight.hollight.DEF_sndcart"
+  "DEF_set_of_list" > "HOLLightList.DEF_set_of_list"
+  "DEF_rem" > "HOLLight.hollight.DEF_rem"
+  "DEF_real_sub" > "HOLLight.hollight.DEF_real_sub"
+  "DEF_real_sgn" > "HOLLight.hollight.DEF_real_sgn"
+  "DEF_real_pow" > "HOLLight.hollight.DEF_real_pow"
+  "DEF_real_of_num" > "HOLLight.hollight.DEF_real_of_num"
+  "DEF_real_neg" > "HOLLight.hollight.DEF_real_neg"
+  "DEF_real_mul" > "HOLLight.hollight.DEF_real_mul"
+  "DEF_real_mod" > "HOLLight.hollight.DEF_real_mod"
+  "DEF_real_min" > "HOLLight.hollight.DEF_real_min"
+  "DEF_real_max" > "HOLLight.hollight.DEF_real_max"
+  "DEF_real_lt" > "HOLLight.hollight.DEF_real_lt"
+  "DEF_real_le" > "HOLLight.hollight.DEF_real_le"
+  "DEF_real_inv" > "HOLLight.hollight.DEF_real_inv"
+  "DEF_real_gt" > "HOLLight.hollight.DEF_real_gt"
+  "DEF_real_ge" > "HOLLight.hollight.DEF_real_ge"
+  "DEF_real_div" > "HOLLight.hollight.DEF_real_div"
+  "DEF_real_add" > "HOLLight.hollight.DEF_real_add"
+  "DEF_real_abs" > "HOLLight.hollight.DEF_real_abs"
+  "DEF_pastecart" > "HOLLight.hollight.DEF_pastecart"
+  "DEF_pairwise" > "HOLLight.hollight.DEF_pairwise"
+  "DEF_o" > "Fun.comp_def"
+  "DEF_num_of_int" > "HOLLight.hollight.DEF_num_of_int"
+  "DEF_num_mod" > "HOLLight.hollight.DEF_num_mod"
+  "DEF_num_gcd" > "HOLLight.hollight.DEF_num_gcd"
+  "DEF_num_divides" > "HOLLight.hollight.DEF_num_divides"
+  "DEF_num_coprime" > "HOLLight.hollight.DEF_num_coprime"
+  "DEF_nsum" > "HOLLight.hollight.DEF_nsum"
+  "DEF_neutral" > "HOLLight.hollight.DEF_neutral"
+  "DEF_nadd_rinv" > "HOLLight.hollight.DEF_nadd_rinv"
+  "DEF_nadd_of_num" > "HOLLight.hollight.DEF_nadd_of_num"
+  "DEF_nadd_mul" > "HOLLight.hollight.DEF_nadd_mul"
+  "DEF_nadd_le" > "HOLLight.hollight.DEF_nadd_le"
+  "DEF_nadd_inv" > "HOLLight.hollight.DEF_nadd_inv"
+  "DEF_nadd_eq" > "HOLLight.hollight.DEF_nadd_eq"
+  "DEF_nadd_add" > "HOLLight.hollight.DEF_nadd_add"
+  "DEF_monoidal" > "HOLLight.hollight.DEF_monoidal"
+  "DEF_minimal" > "HOLLight.hollight.DEF_minimal"
+  "DEF_lambda" > "HOLLight.hollight.DEF_lambda"
+  "DEF_iterate" > "HOLLight.hollight.DEF_iterate"
+  "DEF_is_nadd" > "HOLLight.hollight.DEF_is_nadd"
+  "DEF_integer" > "HOLLight.hollight.DEF_integer"
+  "DEF_int_sub" > "HOLLight.hollight.DEF_int_sub"
+  "DEF_int_sgn" > "HOLLight.hollight.DEF_int_sgn"
+  "DEF_int_pow" > "HOLLight.hollight.DEF_int_pow"
+  "DEF_int_of_num" > "HOLLight.hollight.DEF_int_of_num"
+  "DEF_int_neg" > "HOLLight.hollight.DEF_int_neg"
+  "DEF_int_mul" > "HOLLight.hollight.DEF_int_mul"
+  "DEF_int_mod" > "HOLLight.hollight.DEF_int_mod"
+  "DEF_int_min" > "HOLLight.hollight.DEF_int_min"
+  "DEF_int_max" > "HOLLight.hollight.DEF_int_max"
+  "DEF_int_lt" > "HOLLight.hollight.DEF_int_lt"
+  "DEF_int_le" > "HOLLight.hollight.DEF_int_le"
+  "DEF_int_gt" > "HOLLight.hollight.DEF_int_gt"
+  "DEF_int_ge" > "HOLLight.hollight.DEF_int_ge"
+  "DEF_int_gcd" > "HOLLight.hollight.DEF_int_gcd"
+  "DEF_int_divides" > "HOLLight.hollight.DEF_int_divides"
+  "DEF_int_coprime" > "HOLLight.hollight.DEF_int_coprime"
+  "DEF_int_add" > "HOLLight.hollight.DEF_int_add"
+  "DEF_int_abs" > "HOLLight.hollight.DEF_int_abs"
+  "DEF_hreal_of_num" > "HOLLight.hollight.DEF_hreal_of_num"
+  "DEF_hreal_mul" > "HOLLight.hollight.DEF_hreal_mul"
+  "DEF_hreal_le" > "HOLLight.hollight.DEF_hreal_le"
+  "DEF_hreal_inv" > "HOLLight.hollight.DEF_hreal_inv"
+  "DEF_hreal_add" > "HOLLight.hollight.DEF_hreal_add"
+  "DEF_fstcart" > "HOLLight.hollight.DEF_fstcart"
+  "DEF_div" > "HOLLight.hollight.DEF_div"
+  "DEF_dist" > "HOLLight.hollight.DEF_dist"
+  "DEF_dimindex" > "HOLLight.hollight.DEF_dimindex"
+  "DEF_admissible" > "HOLLight.hollight.DEF_admissible"
+  "DEF__star_" > "HOLLightCompat.DEF__star_"
+  "DEF__slash__backslash_" > "HOLLightCompat.DEF__slash__backslash_"
+  "DEF__questionmark__exclamationmark_" > "HOLLightCompat.EXISTS_UNIQUE_THM"
+  "DEF__questionmark_" > "HOL.Ex_def"
+  "DEF__lessthan__equal__c" > "HOLLight.hollight.DEF__lessthan__equal__c"
+  "DEF__lessthan__equal_" > "HOLLightCompat.DEF__lessthan__equal_"
+  "DEF__lessthan__c" > "HOLLight.hollight.DEF__lessthan__c"
+  "DEF__lessthan_" > "HOLLightCompat.DEF__lessthan_"
+  "DEF__greaterthan__equal__c" > "HOLLight.hollight.DEF__greaterthan__equal__c"
+  "DEF__greaterthan__equal_" > "HOLLightCompat.DEF__greaterthan__equal_"
+  "DEF__greaterthan__c" > "HOLLight.hollight.DEF__greaterthan__c"
+  "DEF__greaterthan_" > "HOLLightCompat.DEF__greaterthan_"
+  "DEF__exclamationmark_" > "HOL.All_def"
+  "DEF__equal__equal__greaterthan_" > "HOLLightCompat.DEF__equal__equal__greaterthan_"
+  "DEF__equal__equal_" > "HOLLight.hollight.DEF__equal__equal_"
+  "DEF__equal__c" > "HOLLight.hollight.DEF__equal__c"
+  "DEF__dot__dot_" > "HOLLightCompat.dotdot_def"
+  "DEF__backslash__slash_" > "HOL.or_def"
+  "DEF__UNGUARDED_PATTERN" > "HOLLight.hollight.DEF__UNGUARDED_PATTERN"
+  "DEF__SEQPATTERN" > "HOLLight.hollight.DEF__SEQPATTERN"
+  "DEF__MATCH" > "HOLLight.hollight.DEF__MATCH"
+  "DEF__GUARDED_PATTERN" > "HOLLight.hollight.DEF__GUARDED_PATTERN"
+  "DEF__FUNCTION" > "HOLLight.hollight.DEF__FUNCTION"
+  "DEF__FALSITY_" > "HOLLight.hollight.DEF__FALSITY_"
+  "DEF__11937" > "HOLLight.hollight.DEF__11937"
+  "DEF_ZRECSPACE" > "HOLLight.hollight.DEF_ZRECSPACE"
+  "DEF_ZCONSTR" > "HOLLight.hollight.DEF_ZCONSTR"
+  "DEF_ZBOT" > "HOLLight.hollight.DEF_ZBOT"
+  "DEF_WF" > "HOLLightCompat.DEF_WF"
+  "DEF_UNIV" > "HOLLightCompat.DEF_UNIV"
+  "DEF_UNIONS" > "HOLLightCompat.DEF_UNIONS"
+  "DEF_UNION" > "HOLLightCompat.DEF_UNION"
+  "DEF_UNCURRY" > "HOLLight.hollight.DEF_UNCURRY"
+  "DEF_T" > "HOL.True_def"
+  "DEF_SURJ" > "HOLLight.hollight.DEF_SURJ"
+  "DEF_SUBSET" > "HOLLightCompat.DEF_SUBSET"
+  "DEF_SND" > "HOLLightCompat.DEF_SND"
+  "DEF_SING" > "HOLLight.hollight.DEF_SING"
+  "DEF_SETSPEC" > "HOLLightCompat.SETSPEC_def"
+  "DEF_REVERSE" > "HOLLightList.DEF_REVERSE"
+  "DEF_REST" > "HOLLight.hollight.DEF_REST"
+  "DEF_REPLICATE" > "HOLLightList.DEF_REPLICATE"
+  "DEF_PSUBSET" > "HOLLightCompat.DEF_PSUBSET"
+  "DEF_PRE" > "HOLLightCompat.DEF_PRE"
+  "DEF_PASSOC" > "HOLLight.hollight.DEF_PASSOC"
+  "DEF_PAIRWISE" > "HOLLight.hollight.DEF_PAIRWISE"
+  "DEF_ONTO" > "Fun.surj_def"
+  "DEF_ONE_ONE" > "HOLLightCompat.DEF_ONE_ONE"
+  "DEF_ODD" > "HOLLightCompat.DEF_ODD"
+  "DEF_NUM_REP" > "HOLLight.hollight.DEF_NUM_REP"
+  "DEF_NUMSUM" > "HOLLight.hollight.DEF_NUMSUM"
+  "DEF_NUMSND" > "HOLLight.hollight.DEF_NUMSND"
+  "DEF_NUMRIGHT" > "HOLLight.hollight.DEF_NUMRIGHT"
+  "DEF_NUMPAIR" > "HOLLight.hollight.DEF_NUMPAIR"
+  "DEF_NUMLEFT" > "HOLLight.hollight.DEF_NUMLEFT"
+  "DEF_NUMFST" > "HOLLight.hollight.DEF_NUMFST"
+  "DEF_NUMERAL" > "HOLLightCompat.NUMERAL_def"
+  "DEF_NULL" > "HOLLightList.DEF_NULL"
+  "DEF_MOD" > "HOLLightCompat.DEF_MOD"
+  "DEF_MIN" > "Orderings.ord_class.min_def"
+  "DEF_MEM" > "HOLLightList.DEF_MEM"
+  "DEF_MEASURE" > "HOLLightCompat.MEASURE_def"
+  "DEF_MAX" > "Orderings.ord_class.max_def"
+  "DEF_MAP" > "HOLLightList.DEF_MAP"
+  "DEF_LET_END" > "HOLLight.hollight.DEF_LET_END"
+  "DEF_LET" > "HOLLightCompat.LET_def"
+  "DEF_LENGTH" > "HOLLightList.DEF_LENGTH"
+  "DEF_LAST" > "HOLLightList.DEF_LAST"
+  "DEF_ITSET" > "HOLLight.hollight.DEF_ITSET"
+  "DEF_ITLIST" > "HOLLightList.DEF_ITLIST"
+  "DEF_ISO" > "HOLLight.hollight.DEF_ISO"
+  "DEF_INTERS" > "HOLLightCompat.DEF_INTERS"
+  "DEF_INTER" > "HOLLightCompat.DEF_INTER"
+  "DEF_INSERT" > "HOLLightCompat.DEF_INSERT"
+  "DEF_INJP" > "HOLLight.hollight.DEF_INJP"
+  "DEF_INJN" > "HOLLight.hollight.DEF_INJN"
+  "DEF_INJF" > "HOLLight.hollight.DEF_INJF"
+  "DEF_INJA" > "HOLLight.hollight.DEF_INJA"
+  "DEF_INJ" > "HOLLight.hollight.DEF_INJ"
+  "DEF_INFINITE" > "HOLLightCompat.DEF_INFINITE"
+  "DEF_IND_SUC" > "HOLLight.hollight.DEF_IND_SUC"
+  "DEF_IND_0" > "HOLLight.hollight.DEF_IND_0"
+  "DEF_IN" > "Set.mem_def"
+  "DEF_IMAGE" > "HOLLightCompat.DEF_IMAGE"
+  "DEF_I" > "Fun.id_apply"
+  "DEF_HAS_SIZE" > "HOLLight.hollight.DEF_HAS_SIZE"
+  "DEF_GSPEC" > "Set.Collect_def"
+  "DEF_GEQ" > "HOLLightCompat.DEF_GEQ"
+  "DEF_GABS" > "HOLLightCompat.DEF_GABS"
+  "DEF_FST" > "HOLLightCompat.DEF_FST"
+  "DEF_FNIL" > "HOLLight.hollight.DEF_FNIL"
+  "DEF_FINREC" > "HOLLight.hollight.DEF_FINREC"
+  "DEF_FINITE" > "HOLLightCompat.DEF_FINITE"
+  "DEF_FILTER" > "HOLLightList.DEF_FILTER"
+  "DEF_FCONS" > "HOLLight.hollight.DEF_FCONS"
+  "DEF_FACT" > "HOLLightCompat.DEF_FACT"
+  "DEF_F" > "HOL.False_def"
+  "DEF_EXP" > "HOLLightCompat.DEF_EXP"
+  "DEF_EX" > "HOLLightList.DEF_EX"
+  "DEF_EVEN" > "HOLLightCompat.DEF_EVEN"
+  "DEF_EMPTY" > "HOLLightCompat.DEF_EMPTY"
+  "DEF_EL" > "HOLLightList.DEF_EL"
+  "DEF_DIV" > "HOLLightCompat.DEF_DIV"
+  "DEF_DISJOINT" > "HOLLightCompat.DEF_DISJOINT"
+  "DEF_DIFF" > "HOLLightCompat.DEF_DIFF"
+  "DEF_DELETE" > "HOLLightCompat.DEF_DELETE"
+  "DEF_DECIMAL" > "HOLLight.hollight.DEF_DECIMAL"
+  "DEF_CURRY" > "Product_Type.curry_conv"
+  "DEF_CROSS" > "HOLLight.hollight.DEF_CROSS"
+  "DEF_COUNTABLE" > "HOLLight.hollight.DEF_COUNTABLE"
+  "DEF_CONSTR" > "HOLLight.hollight.DEF_CONSTR"
+  "DEF_COND" > "HOLLightCompat.COND_DEF"
+  "DEF_CHOICE" > "HOLLightCompat.DEF_CHOICE"
+  "DEF_CASEWISE" > "HOLLight.hollight.DEF_CASEWISE"
+  "DEF_CARD" > "HOLLight.hollight.DEF_CARD"
+  "DEF_BUTLAST" > "HOLLightList.DEF_BUTLAST"
+  "DEF_BOTTOM" > "HOLLight.hollight.DEF_BOTTOM"
+  "DEF_BIT1" > "HOLLightCompat.BIT1_DEF"
+  "DEF_BIT0" > "HOLLightCompat.BIT0_DEF"
+  "DEF_BIJ" > "HOLLight.hollight.DEF_BIJ"
+  "DEF_ASCII" > "HOLLight.hollight.DEF_ASCII"
+  "DEF_APPEND" > "HOLLightList.DEF_APPEND"
+  "DEF_ALL2" > "HOLLightList.DEF_ALL2"
+  "DEF_ALL" > "HOLLightList.DEF_ALL"
+  "DEF_-" > "HOLLightCompat.DEF_MINUS"
+  "DEF_+" > "HOLLightCompat.DEF_PLUS"
+  "DEF_$" > "HOLLight.hollight.DEF_$"
+  "DECOMPOSITION" > "HOLLight.hollight.DECOMPOSITION"
+  "DECIMAL_def" > "HOLLight.hollight.DECIMAL_def"
+  "CROSS_def" > "HOLLight.hollight.CROSS_def"
+  "CROSS_EQ_EMPTY" > "HOLLight.hollight.CROSS_EQ_EMPTY"
+  "COUNTABLE_def" > "HOLLight.hollight.COUNTABLE_def"
+  "CONS_HD_TL" > "List.hd_Cons_tl"
+  "CONS_11" > "List.list.inject"
+  "CONSTR_def" > "HOLLight.hollight.CONSTR_def"
+  "CONSTR_REC" > "HOLLight.hollight.CONSTR_REC"
+  "CONSTR_INJ" > "HOLLight.hollight.CONSTR_INJ"
+  "CONSTR_IND" > "HOLLight.hollight.CONSTR_IND"
+  "CONSTR_BOT" > "HOLLight.hollight.CONSTR_BOT"
+  "CONJ_SYM" > "Groebner_Basis.dnf_3"
+  "CONJ_ASSOC" > "HOL.conj_ac_3"
+  "CONJ_ACI" > "HOLLight.hollight.CONJ_ACI"
+  "COND_RATOR" > "HOLLight.hollight.COND_RATOR"
+  "COND_RAND" > "HOL.if_distrib"
+  "COND_ID" > "HOL.if_cancel"
+  "COND_EXPAND" > "HOLLight.hollight.COND_EXPAND"
+  "COND_EQ_CLAUSE" > "HOLLight.hollight.COND_EQ_CLAUSE"
+  "COND_ELIM_THM" > "HOL.if_splits_1"
+  "COND_CLAUSES" > "HOLLight.hollight.COND_CLAUSES"
+  "COND_ABS" > "HOLLight.hollight.COND_ABS"
+  "COMPONENT" > "Set.insertI1"
+  "CHOOSE_SUBSET_STRONG" > "HOLLight.hollight.CHOOSE_SUBSET_STRONG"
+  "CHOOSE_SUBSET" > "HOLLight.hollight.CHOOSE_SUBSET"
+  "CHOICE_DEF" > "HOLLight.hollight.CHOICE_DEF"
+  "CASEWISE_def" > "HOLLight.hollight.CASEWISE_def"
+  "CART_EQ_FULL" > "HOLLight.hollight.CART_EQ_FULL"
+  "CART_EQ" > "HOLLight.hollight.CART_EQ"
+  "CARD_def" > "HOLLight.hollight.CARD_def"
+  "CARD_UNION_OVERLAP_EQ" > "HOLLight.hollight.CARD_UNION_OVERLAP_EQ"
+  "CARD_UNION_OVERLAP" > "HOLLight.hollight.CARD_UNION_OVERLAP"
+  "CARD_UNION_LE" > "HOLLight.hollight.CARD_UNION_LE"
+  "CARD_UNION_GEN" > "HOLLight.hollight.CARD_UNION_GEN"
+  "CARD_UNION_EQ" > "HOLLight.hollight.CARD_UNION_EQ"
+  "CARD_UNIONS_LE" > "HOLLight.hollight.CARD_UNIONS_LE"
+  "CARD_UNIONS" > "HOLLight.hollight.CARD_UNIONS"
+  "CARD_UNION" > "HOLLight.hollight.CARD_UNION"
+  "CARD_SUBSET_LE" > "HOLLight.hollight.CARD_SUBSET_LE"
+  "CARD_SUBSET_IMAGE" > "HOLLight.hollight.CARD_SUBSET_IMAGE"
+  "CARD_SUBSET_EQ" > "HOLLight.hollight.CARD_SUBSET_EQ"
+  "CARD_SUBSET" > "HOLLight.hollight.CARD_SUBSET"
+  "CARD_PSUBSET" > "HOLLight.hollight.CARD_PSUBSET"
+  "CARD_PRODUCT" > "HOLLight.hollight.CARD_PRODUCT"
+  "CARD_POWERSET" > "HOLLight.hollight.CARD_POWERSET"
+  "CARD_NUMSEG_LT" > "HOLLight.hollight.CARD_NUMSEG_LT"
+  "CARD_NUMSEG_LEMMA" > "HOLLight.hollight.CARD_NUMSEG_LEMMA"
+  "CARD_NUMSEG_LE" > "HOLLight.hollight.CARD_NUMSEG_LE"
+  "CARD_NUMSEG_1" > "HOLLight.hollight.CARD_NUMSEG_1"
+  "CARD_NUMSEG" > "HOLLight.hollight.CARD_NUMSEG"
+  "CARD_LE_INJ" > "HOLLight.hollight.CARD_LE_INJ"
+  "CARD_IMAGE_LE" > "HOLLight.hollight.CARD_IMAGE_LE"
+  "CARD_IMAGE_INJ_EQ" > "HOLLight.hollight.CARD_IMAGE_INJ_EQ"
+  "CARD_IMAGE_INJ" > "HOLLight.hollight.CARD_IMAGE_INJ"
+  "CARD_FUNSPACE" > "HOLLight.hollight.CARD_FUNSPACE"
+  "CARD_FINITE_IMAGE" > "HOLLight.hollight.CARD_FINITE_IMAGE"
+  "CARD_EQ_SUM" > "HOLLight.hollight.CARD_EQ_SUM"
+  "CARD_EQ_NSUM" > "HOLLight.hollight.CARD_EQ_NSUM"
+  "CARD_EQ_BIJECTIONS" > "HOLLight.hollight.CARD_EQ_BIJECTIONS"
+  "CARD_EQ_BIJECTION" > "HOLLight.hollight.CARD_EQ_BIJECTION"
+  "CARD_EQ_0" > "HOLLight.hollight.CARD_EQ_0"
+  "CARD_DIFF" > "HOLLight.hollight.CARD_DIFF"
+  "CARD_DELETE" > "HOLLight.hollight.CARD_DELETE"
+  "CARD_CROSS" > "HOLLight.hollight.CARD_CROSS"
+  "CARD_CLAUSES" > "HOLLight.hollight.CARD_CLAUSES"
+  "BOUNDS_NOTZERO" > "HOLLight.hollight.BOUNDS_NOTZERO"
+  "BOUNDS_LINEAR_0" > "HOLLight.hollight.BOUNDS_LINEAR_0"
+  "BOUNDS_LINEAR" > "HOLLight.hollight.BOUNDS_LINEAR"
+  "BOUNDS_IGNORE" > "HOLLight.hollight.BOUNDS_IGNORE"
+  "BOUNDS_DIVIDED" > "HOLLight.hollight.BOUNDS_DIVIDED"
+  "BOTTOM_def" > "HOLLight.hollight.BOTTOM_def"
+  "BOOL_CASES_AX" > "HOL.True_or_False"
+  "BIT1_THM" > "HOLLight.hollight.BIT1_THM"
+  "BIT1" > "HOLLight.hollight.BIT1"
+  "BIT0_THM" > "Int.semiring_mult_2"
+  "BIT0" > "Int.semiring_mult_2"
+  "BIJ_def" > "HOLLight.hollight.BIJ_def"
+  "BIJECTIVE_ON_LEFT_RIGHT_INVERSE" > "HOLLight.hollight.BIJECTIVE_ON_LEFT_RIGHT_INVERSE"
+  "BIJECTIVE_LEFT_RIGHT_INVERSE" > "HOLLight.hollight.BIJECTIVE_LEFT_RIGHT_INVERSE"
+  "BIJECTIONS_HAS_SIZE_EQ" > "HOLLight.hollight.BIJECTIONS_HAS_SIZE_EQ"
+  "BIJECTIONS_HAS_SIZE" > "HOLLight.hollight.BIJECTIONS_HAS_SIZE"
+  "BIJECTIONS_CARD_EQ" > "HOLLight.hollight.BIJECTIONS_CARD_EQ"
+  "BETA_THM" > "HOL.eta_contract_eq"
+  "ASCII_def" > "HOLLight.hollight.ASCII_def"
+  "ARITH_ZERO" > "HOLLight.hollight.ARITH_ZERO"
+  "ARITH_SUC" > "HOLLight.hollight.ARITH_SUC"
+  "ARITH_SUB" > "HOLLight.hollight.ARITH_SUB"
+  "ARITH_PRE" > "HOLLight.hollight.ARITH_PRE"
+  "ARITH_ODD" > "HOLLight.hollight.ARITH_ODD"
+  "ARITH_MULT" > "HOLLight.hollight.ARITH_MULT"
+  "ARITH_LT" > "HOLLight.hollight.ARITH_LT"
+  "ARITH_LE" > "HOLLight.hollight.ARITH_LE"
+  "ARITH_EXP" > "HOLLight.hollight.ARITH_EXP"
+  "ARITH_EVEN" > "HOLLight.hollight.ARITH_EVEN"
+  "ARITH_EQ" > "HOLLight.hollight.ARITH_EQ"
+  "ARITH_ADD" > "HOLLight.hollight.ARITH_ADD"
+  "APPEND_NIL" > "List.append_Nil2"
+  "APPEND_EQ_NIL" > "List.append_is_Nil_conv"
+  "APPEND_BUTLAST_LAST" > "List.append_butlast_last_id"
+  "APPEND_ASSOC" > "List.append_assoc"
+  "AND_FORALL_THM" > "HOL.all_conj_distrib"
+  "AND_CLAUSES" > "HOLLight.hollight.AND_CLAUSES"
+  "AND_ALL2" > "HOLLightList.AND_ALL2"
+  "AND_ALL" > "HOLLightList.AND_ALL"
+  "ALL_T" > "HOLLightList.ALL_T"
+  "ALL_MP" > "HOLLightList.ALL_MP"
+  "ALL_MEM" > "HOLLightList.ALL_MEM"
+  "ALL_IMP" > "HOLLightList.ALL_IMP"
+  "ALL_EL" > "List.list_all_length"
+  "ALL_APPEND" > "List.list_all_append"
+  "ALL2_MAP2" > "HOLLightList.ALL2_MAP2"
+  "ALL2_MAP" > "HOLLightList.ALL2_MAP"
+  "ALL2_AND_RIGHT" > "HOLLightList.ALL2_AND_RIGHT"
+  "ALL2_ALL" > "HOLLightList.ALL2_ALL"
+  "ALL2" > "HOLLightList.ALL2"
+  "ADMISSIBLE_UNGUARDED_PATTERN" > "HOLLight.hollight.ADMISSIBLE_UNGUARDED_PATTERN"
+  "ADMISSIBLE_SUM" > "HOLLight.hollight.ADMISSIBLE_SUM"
+  "ADMISSIBLE_SEQPATTERN" > "HOLLight.hollight.ADMISSIBLE_SEQPATTERN"
+  "ADMISSIBLE_RAND" > "HOLLight.hollight.ADMISSIBLE_RAND"
+  "ADMISSIBLE_NSUM" > "HOLLight.hollight.ADMISSIBLE_NSUM"
+  "ADMISSIBLE_NEST" > "HOLLight.hollight.ADMISSIBLE_NEST"
+  "ADMISSIBLE_MATCH_SEQPATTERN" > "HOLLight.hollight.ADMISSIBLE_MATCH_SEQPATTERN"
+  "ADMISSIBLE_MATCH" > "HOLLight.hollight.ADMISSIBLE_MATCH"
+  "ADMISSIBLE_MAP" > "HOLLight.hollight.ADMISSIBLE_MAP"
+  "ADMISSIBLE_LAMBDA" > "HOLLight.hollight.ADMISSIBLE_LAMBDA"
+  "ADMISSIBLE_IMP_SUPERADMISSIBLE" > "HOLLight.hollight.ADMISSIBLE_IMP_SUPERADMISSIBLE"
+  "ADMISSIBLE_GUARDED_PATTERN" > "HOLLight.hollight.ADMISSIBLE_GUARDED_PATTERN"
+  "ADMISSIBLE_CONST" > "HOLLight.hollight.ADMISSIBLE_CONST"
+  "ADMISSIBLE_COND" > "HOLLight.hollight.ADMISSIBLE_COND"
+  "ADMISSIBLE_COMB" > "HOLLight.hollight.ADMISSIBLE_COMB"
+  "ADMISSIBLE_BASE" > "HOLLight.hollight.ADMISSIBLE_BASE"
+  "ADD_SYM" > "Fields.linordered_field_class.sign_simps_43"
+  "ADD_SUC" > "Nat.add_Suc_right"
+  "ADD_SUBR2" > "Nat.diff_add_0"
+  "ADD_SUBR" > "HOLLight.hollight.ADD_SUBR"
+  "ADD_SUB2" > "Nat.diff_add_inverse"
+  "ADD_SUB" > "Nat.diff_add_inverse2"
+  "ADD_EQ_0" > "Nat.add_is_0"
+  "ADD_CLAUSES" > "HOLLight.hollight.ADD_CLAUSES"
+  "ADD_ASSOC" > "Fields.linordered_field_class.sign_simps_44"
+  "ADD_AC" > "HOLLight.hollight.ADD_AC"
+  "ADD_0" > "Divides.arithmetic_simps_39"
+  "ADD1" > "Nat_Numeral.Suc_eq_plus1"
+  "ABS_SIMP" > "HOL.refl"
+  "ABSORPTION" > "HOLLight.hollight.ABSORPTION"
+  ">_c_def" > "HOLLight.hollight.>_c_def"
+  ">=_c_def" > "HOLLight.hollight.>=_c_def"
+  "=_c_def" > "HOLLight.hollight.=_c_def"
+  "<_c_def" > "HOLLight.hollight.<_c_def"
+  "<=_c_def" > "HOLLight.hollight.<=_c_def"
+  "$_def" > "HOLLight.hollight.$_def"
+
+ignore_thms
+  "WF_REC_CASES"
+  "TYDEF_sum"
+  "TYDEF_prod"
+  "TYDEF_option"
+  "TYDEF_num"
+  "TYDEF_list"
+  "TYDEF_1"
+  "SNDCART_PASTECART"
+  "SET_OF_LIST_OF_SET"
+  "REP_ABS_PAIR"
+  "RECURSION_CASEWISE_PAIRWISE"
+  "RECURSION_CASEWISE"
+  "PASTECART_FST_SND"
+  "PASTECART_EQ"
+  "MEM_LIST_OF_SET"
+  "MEM_ASSOC"
+  "LIST_OF_SET_PROPERTIES"
+  "LENGTH_LIST_OF_SET"
+  "HAS_SIZE_SET_OF_LIST"
+  "FSTCART_PASTECART"
+  "FORALL_PASTECART"
+  "FINITE_SET_OF_LIST"
+  "EX_MAP"
+  "EXISTS_PASTECART"
+  "EL_TL"
+  "DIMINDEX_HAS_SIZE_FINITE_SUM"
+  "DIMINDEX_FINITE_SUM"
+  "DEF_one"
+  "DEF_mk_pair"
+  "DEF_list_of_set"
+  "DEF__0"
+  "DEF_ZIP"
+  "DEF_TL"
+  "DEF_SUC"
+  "DEF_SOME"
+  "DEF_OUTR"
+  "DEF_OUTL"
+  "DEF_NONE"
+  "DEF_NIL"
+  "DEF_MAP2"
+  "DEF_ITLIST2"
+  "DEF_INR"
+  "DEF_INL"
+  "DEF_HD"
+  "DEF_CONS"
+  "DEF_ASSOC"
+  "DEF_,"
+  "CASEWISE_WORKS"
+  "CASEWISE_CASES"
+  "CASEWISE"
+  "CARD_SET_OF_LIST_LE"
+  "ALL_MAP"
+
+end
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/HOL_Light/Template/GenHOLLight.thy
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOL_Light/Template/GenHOLLight.thy	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,220 @@
+(*  Title:      HOL/Import/Generate-HOLLight/GenHOLLight.thy
+    Author:     Steven Obua, TU Muenchen
+    Author:     Cezary Kaliszyk
+*)
+
+theory GenHOLLight
+imports "../../HOL4Syntax" "../Compatibility"
+begin
+
+import_segment "hollight"
+
+setup_dump "../Generated" "HOLLight"
+
+append_dump {*theory HOL4Base
+imports "../../HOL4Syntax" "../Compatibility"
+begin
+*}
+
+import_theory "~~/src/HOL/Import/HOL_Light/Generated" hollight
+
+;ignore_thms
+  (* Unit type *)
+  TYDEF_1 DEF_one
+  (* Product type *)
+  TYDEF_prod "DEF_," DEF_mk_pair REP_ABS_PAIR
+  (* Option type *)
+  TYDEF_option DEF_NONE DEF_SOME
+  (* Sum type *)
+  TYDEF_sum DEF_INL DEF_INR DEF_OUTL DEF_OUTR
+  (* Naturals *)
+  TYDEF_num DEF__0 DEF_SUC
+  (* Lists *)
+  TYDEF_list DEF_NIL DEF_CONS DEF_HD DEF_TL DEF_MAP2 DEF_ITLIST2 ALL_MAP EX_MAP
+  DEF_ASSOC MEM_ASSOC DEF_ZIP EL_TL
+
+  (* list_of_set uses Isabelle lists with HOLLight CARD *)
+  DEF_list_of_set LIST_OF_SET_PROPERTIES SET_OF_LIST_OF_SET LENGTH_LIST_OF_SET
+  MEM_LIST_OF_SET HAS_SIZE_SET_OF_LIST FINITE_SET_OF_LIST
+  (* UNIV *)
+  DIMINDEX_FINITE_SUM  DIMINDEX_HAS_SIZE_FINITE_SUM FSTCART_PASTECART
+  SNDCART_PASTECART PASTECART_FST_SND PASTECART_EQ FORALL_PASTECART EXISTS_PASTECART
+  (* Reals *)
+  (* TYDEF_real DEF_real_of_num DEF_real_neg DEF_real_add DEF_real_mul DEF_real_le
+  DEF_real_inv REAL_HREAL_LEMMA1 REAL_HREAL_LEMMA2 *)
+  (* Integers *)
+  (* TYDEF_int DEF_int_divides DEF_int_coprime*)
+  (* HOLLight CARD and CASEWISE with Isabelle lists *)
+  CARD_SET_OF_LIST_LE CASEWISE CASEWISE_CASES RECURSION_CASEWISE CASEWISE_WORKS
+  WF_REC_CASES RECURSION_CASEWISE_PAIRWISE
+
+;type_maps
+  bool > HOL.bool
+  "fun" > "fun"
+  N_1 >  Product_Type.unit
+  prod > Product_Type.prod
+  ind > Nat.ind
+  num > Nat.nat
+  sum > Sum_Type.sum
+  option > Datatype.option
+  list > List.list
+(*real > RealDef.real *)
+(*int > Int.int *)
+
+;const_renames
+  "==" > "eqeq"
+  "ALL" > list_ALL
+  "EX" > list_EX
+
+;const_maps
+  T > HOL.True
+  F > HOL.False
+  "=" > HOL.eq
+  "==>" > HOL.implies
+  "/\\" > HOL.conj
+  "\\/" > HOL.disj
+  "!" > HOL.All
+  "?" > HOL.Ex
+  "?!" > HOL.Ex1
+  "~" > HOL.Not
+  COND > HOL.If
+  ONE_ONE > Fun.inj
+  ONTO > Fun.surj
+  o > Fun.comp
+  "@" > Hilbert_Choice.Eps
+  CHOICE > Hilbert_Choice.Eps
+  I > Fun.id
+  one > Product_Type.Unity
+  LET > HOLLightCompat.LET
+  mk_pair > Product_Type.Pair_Rep
+  "," > Product_Type.Pair
+  FST > Product_Type.fst
+  SND > Product_Type.snd
+  CURRY > Product_Type.curry
+  "_0" > Groups.zero_class.zero :: nat
+  SUC > Nat.Suc
+  PRE > HOLLightCompat.Pred
+  NUMERAL > HOLLightCompat.NUMERAL
+  mk_num > Fun.id
+  "+" > Groups.plus_class.plus :: "nat \<Rightarrow> nat \<Rightarrow> nat"
+  "*" > Groups.times_class.times :: "nat \<Rightarrow> nat \<Rightarrow> nat"
+  "-" > Groups.minus_class.minus :: "nat \<Rightarrow> nat \<Rightarrow> nat"
+  "<" > Orderings.ord_class.less :: "nat \<Rightarrow> nat \<Rightarrow> bool"
+  "<=" > Orderings.ord_class.less_eq :: "nat \<Rightarrow> nat \<Rightarrow> bool"
+  ">" > Orderings.ord_class.greater :: "nat \<Rightarrow> nat \<Rightarrow> bool"
+  ">=" > Orderings.ord_class.greater_eq :: "nat \<Rightarrow> nat \<Rightarrow> bool"
+  EXP > Power.power_class.power :: "nat \<Rightarrow> nat \<Rightarrow> nat"
+  MAX > Orderings.ord_class.max :: "nat \<Rightarrow> nat \<Rightarrow> nat"
+  MIN > Orderings.ord_class.min :: "nat \<Rightarrow> nat \<Rightarrow> nat"
+  DIV > Divides.div_class.div :: "nat \<Rightarrow> nat \<Rightarrow> nat"
+  MOD > Divides.div_class.mod :: "nat \<Rightarrow> nat \<Rightarrow> nat"
+  BIT0 > HOLLightCompat.NUMERAL_BIT0
+  BIT1 > HOLLightCompat.NUMERAL_BIT1
+  INL > Sum_Type.Inl
+  INR > Sum_Type.Inr
+  OUTL > HOLLightCompat.OUTL
+  OUTR > HOLLightCompat.OUTR
+  NONE > Datatype.None
+  SOME > Datatype.Some
+  EVEN > Parity.even_odd_class.even :: "nat \<Rightarrow> bool"
+  ODD > HOLLightCompat.ODD
+  FACT > Fact.fact_class.fact :: "nat \<Rightarrow> nat"
+  WF > Wellfounded.wfP
+  NIL > List.list.Nil
+  CONS > List.list.Cons
+  APPEND > List.append
+  REVERSE > List.rev
+  LENGTH > List.length
+  MAP > List.map
+  LAST > List.last
+  BUTLAST > List.butlast
+  REPLICATE > List.replicate
+  ITLIST > List.foldr
+  list_ALL > List.list_all
+  ALL2 > List.list_all2
+  list_EX > List.list_ex
+  FILTER > List.filter
+  NULL > List.null
+  HD > List.hd
+  TL > List.tl
+  EL > HOLLightList.list_el
+  ZIP > List.zip
+  MAP2 > HOLLightList.map2
+  ITLIST2 > HOLLightList.fold2
+  MEM > HOLLightList.list_mem
+  set_of_list > List.set
+  IN > Set.member
+  INSERT > Set.insert
+  EMPTY > Orderings.bot_class.bot :: "'a \<Rightarrow> bool"
+  GABS > Hilbert_Choice.Eps
+  GEQ > HOL.eq
+  GSPEC > Set.Collect
+  SETSPEC > HOLLightCompat.SETSPEC
+  UNION > Lattices.sup_class.sup :: "('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> 'a \<Rightarrow> bool"
+  UNIONS > Complete_Lattices.Sup_class.Sup :: "(('a \<Rightarrow> bool) \<Rightarrow> bool) \<Rightarrow> 'a \<Rightarrow> bool"
+  INTER > Lattices.inf_class.inf :: "('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> 'a \<Rightarrow> bool"
+  INTERS > Complete_Lattices.Inf_class.Inf :: "(('a \<Rightarrow> bool) \<Rightarrow> bool) \<Rightarrow> 'a \<Rightarrow> bool"
+  DIFF > Groups.minus_class.minus :: "('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> 'a \<Rightarrow> bool"
+  SUBSET > Orderings.ord_class.less_eq :: "('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> bool"
+  PSUBSET > Orderings.ord_class.less :: "('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> bool"
+  DELETE > HOLLightCompat.DELETE
+  DISJOINT > HOLLightCompat.DISJOINT
+  IMAGE > Set.image
+  FINITE > Finite_Set.finite
+  INFINITE > HOLLightCompat.INFINITE
+  ".." > HOLLightCompat.dotdot
+  UNIV > Orderings.top_class.top :: "'a \<Rightarrow> bool"
+  MEASURE > HOLLightCompat.MEASURE
+(*real_of_num > RealDef.real :: "nat => real"
+  real_neg > Groups.uminus_class.uminus :: "real => 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 \<Rightarrow> real \<Rightarrow> bool"
+  real_le > Orderings.ord_class.less_eq :: "real \<Rightarrow> real \<Rightarrow> bool"
+  real_gt > Orderings.ord_class.greater :: "real \<Rightarrow> real \<Rightarrow> bool"
+  real_ge > Orderings.ord_class.greater_eq :: "real \<Rightarrow> real \<Rightarrow> bool"
+  real_pow > Power.power_class.power :: "real \<Rightarrow> nat \<Rightarrow> real"
+  real_abs > Groups.abs_class.abs :: "real \<Rightarrow> real"
+  real_max > Orderings.ord_class.max :: "real \<Rightarrow> real \<Rightarrow> real"
+  real_min > Orderings.ord_class.min :: "real \<Rightarrow> real \<Rightarrow> real"
+  real_sgn > Groups.sgn_class.sgn :: "real \<Rightarrow> real"*)
+(*real_of_int > RealDef.real :: "int => real"
+  int_of_real > Archimedean_Field.floor :: "real \<Rightarrow> int"
+  dest_int > RealDef.real :: "int => real"
+  mk_int > Archimedean_Field.floor :: "real \<Rightarrow> int"
+  int_lt > Orderings.ord_class.less :: "int \<Rightarrow> int \<Rightarrow> bool"
+  int_le > Orderings.ord_class.less_eq :: "int \<Rightarrow> int \<Rightarrow> bool"
+  int_gt > Orderings.ord_class.greater :: "int \<Rightarrow> int \<Rightarrow> bool"
+  int_ge > Orderings.ord_class.greater_eq :: "int \<Rightarrow> int \<Rightarrow> bool"
+  int_of_num > Nat.semiring_1_class.of_nat :: "nat \<Rightarrow> int"
+  int_neg > Groups.uminus_class.uminus :: "int \<Rightarrow> int"
+  int_add > Groups.plus_class.plus :: "int => int => int"
+  int_sub > Groups.minus_class.minus :: "int => int => int"
+  int_mul > Groups.times_class.times :: "int => int => int"
+  int_abs > Groups.abs_class.abs :: "int \<Rightarrow> int"
+  int_max > Orderings.ord_class.max :: "int \<Rightarrow> int \<Rightarrow> int"
+  int_min > Orderings.ord_class.min :: "int \<Rightarrow> int \<Rightarrow> int"
+  int_sgn > Groups.sgn_class.sgn :: "int \<Rightarrow> int"
+  int_pow > Power.power_class.power :: "int \<Rightarrow> nat \<Rightarrow> int"
+  int_div > HOLLightInt.hl_div :: "int \<Rightarrow> int \<Rightarrow> int"
+  div > HOLLightInt.hl_div :: "int \<Rightarrow> int \<Rightarrow> int"
+  mod_int > HOLLightInt.hl_mod :: "int \<Rightarrow> int \<Rightarrow> int"
+  rem > HOLLightInt.hl_mod :: "int \<Rightarrow> int \<Rightarrow> int"
+  int_divides > Rings.dvd_class.dvd :: "int \<Rightarrow> int \<Rightarrow> bool"
+  int_mod > HOLLightInt.int_mod :: "int \<Rightarrow> int \<Rightarrow> int \<Rightarrow> bool"
+  int_gcd > HOLLightInt.int_gcd :: "int \<times> int \<Rightarrow> int"
+  int_coprime > HOLLightInt.int_coprime :: "int \<times> int \<Rightarrow> bool"
+  eqeq > HOLLightInt.eqeq*)
+
+;end_import
+
+;append_dump "end"
+
+;flush_dump
+
+;import_segment ""
+
+end
diff -r f0285e69d704 -r 3d3d8f8929a7 src/HOL/Import/README
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/README	Sat Mar 03 22:37:41 2012 +0100
@@ -0,0 +1,19 @@
+
+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, HOL4.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 HOL4 proofs are not consulted
+at all.  If a real replay of the HOL4 proofs is desired, get and
+unpack the HOL4 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.