Loading theory "HOL-Library.Cancellation" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Determinants" via "HOL-Library.Permutations" via "HOL-Library.Multiset")
Loading theory "HOL-Library.Disjoint_Sets" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Determinants" via "HOL-Library.Permutations")
Loading theory "HOL-Library.FuncSet" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Determinants" via "HOL-Analysis.Cartesian_Space" via "HOL-Analysis.Finite_Cartesian_Product")
Loading theory "HOL-Library.Infinite_Set" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Convex" via "HOL-Analysis.Linear_Algebra")
Loading theory "HOL-Library.Old_Datatype" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Determinants" via "HOL-Analysis.Cartesian_Space" via "HOL-Analysis.Finite_Cartesian_Product" via "HOL-Library.Countable_Set" via "HOL-Library.Countable")
Loading theory "HOL-Library.Nat_Bijection" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Determinants" via "HOL-Analysis.Cartesian_Space" via "HOL-Analysis.Finite_Cartesian_Product" via "HOL-Library.Countable_Set" via "HOL-Library.Countable")
Found termination order: "(\<lambda>p. size (snd p)) <*mlex*> {}"
consts
  enumerate :: "'a set \<Rightarrow> nat \<Rightarrow> 'a"
### theory "HOL-Library.Disjoint_Sets"
### 0.323s elapsed time, 1.940s cpu time, 0.000s GC time
Loading theory "HOL-Library.Phantom_Type" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Determinants" via "HOL-Analysis.Cartesian_Space" via "HOL-Analysis.Finite_Cartesian_Product" via "HOL-Library.Numeral_Type" via "HOL-Library.Cardinality")
Found termination order: "size_list size <*mlex*> {}"
### theory "HOL-Library.Infinite_Set"
### 0.377s elapsed time, 2.256s cpu time, 0.000s GC time
Loading theory "HOL-Library.Product_Plus" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Convex" via "HOL-Analysis.Linear_Algebra" via "HOL-Analysis.Euclidean_Space" via "HOL-Analysis.Product_Vector")
instantiation
  prod :: (zero, zero) zero
  zero_prod == zero_class.zero :: 'a \<times> 'b
instantiation
  prod :: (plus, plus) plus
  plus_prod == plus ::
    'a \<times> 'b \<Rightarrow> 'a \<times> 'b \<Rightarrow> 'a \<times> 'b
instantiation
  prod :: (minus, minus) minus
  minus_prod == minus ::
    'a \<times> 'b \<Rightarrow> 'a \<times> 'b \<Rightarrow> 'a \<times> 'b
instantiation
  prod :: (uminus, uminus) uminus
  uminus_prod == uminus :: 'a \<times> 'b \<Rightarrow> 'a \<times> 'b
signature CANCEL = sig val proc: Proof.context -> cterm -> thm option end
functor Cancel_Fun (Data: CANCEL_NUMERALS_DATA): CANCEL
### theory "HOL-Library.Product_Plus"
### 0.128s elapsed time, 0.756s cpu time, 0.000s GC time
Loading theory "HOL-Library.Product_Order" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Henstock_Kurzweil_Integration" via "HOL-Analysis.Lebesgue_Measure" via "HOL-Analysis.Finite_Product_Measure" via "HOL-Analysis.Binary_Product_Measure" via "HOL-Analysis.Nonnegative_Lebesgue_Integration" via "HOL-Analysis.Borel_Space" via "HOL-Analysis.Ordered_Euclidean_Space")
### theory "HOL-Library.Nat_Bijection"
### 0.528s elapsed time, 3.156s cpu time, 0.000s GC time
Loading theory "HOL-Library.Set_Algebras" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Convex")
instantiation
  prod :: (ord, ord) ord
  less_eq_prod == less_eq ::
    'a \<times> 'b \<Rightarrow> 'a \<times> 'b \<Rightarrow> bool
  less_prod == less ::
    'a \<times> 'b \<Rightarrow> 'a \<times> 'b \<Rightarrow> bool
signature CANCEL_DATA =
  sig
    val dest_coeff: term -> int * term
    val dest_sum: term -> term list
    val find_first_coeff: term -> term list -> int * term list
    val mk_coeff: int * term -> term
    val mk_sum: typ -> term list -> term
    val norm_ss1: simpset
    val norm_ss2: simpset
    val norm_tac: Proof.context -> tactic
    val numeral_simp_tac: Proof.context -> tactic
    val prove_conv:
       tactic list -> Proof.context -> thm list -> term * term -> thm option
    val simplify_meta_eq: Proof.context -> thm -> thm
    val trans_tac: Proof.context -> thm option -> tactic
  end
structure Cancel_Data: CANCEL_DATA
instantiation
  set :: (plus) plus
  plus_set == plus :: 'a set \<Rightarrow> 'a set \<Rightarrow> 'a set
instantiation
  set :: (times) times
  times_set == times :: 'a set \<Rightarrow> 'a set \<Rightarrow> 'a set
instantiation
  prod :: (inf, inf) inf
  inf_prod == inf ::
    'a \<times> 'b \<Rightarrow> 'a \<times> 'b \<Rightarrow> 'a \<times> 'b
instantiation
  set :: (zero) zero
  zero_set == zero_class.zero :: 'a set
instantiation
  set :: (one) one
  one_set == one_class.one :: 'a set
instantiation
  prod :: (sup, sup) sup
  sup_prod == sup ::
    'a \<times> 'b \<Rightarrow> 'a \<times> 'b \<Rightarrow> 'a \<times> 'b
instantiation
  prod :: (top, top) top
  top_prod == top :: 'a \<times> 'b
signature OLD_DATATYPE =
  sig
    val check_specs: spec list -> theory -> spec list * Proof.context
    type config = {quiet: bool, strict: bool}
    val default_config: config
    type descr =
       (int * (string * dtyp list * (string * dtyp list) list)) list
    val distinct_lemma: thm
    datatype dtyp
    = DtRec of int | DtTFree of string * sort | DtType of string * dtyp list
    type info =
       {case_cong: thm,
        case_cong_weak: thm,
        case_name: string,
        case_rewrites: thm list,
        descr: descr,
        distinct: thm list,
        exhaust: thm,
        index: int,
        induct: thm,
        inducts: thm list,
        inject: thm list,
        nchotomy: thm,
        rec_names: string list,
        rec_rewrites: thm list, split: thm, split_asm: thm}
    val read_specs: spec_cmd list -> theory -> spec list * Proof.context
    type spec =
       (binding * (string * sort) list * mixfix) *
       (binding * typ list * mixfix) list
    type spec_cmd =
       (binding * (string * string option) list * mixfix) *
       (binding * string list * mixfix) list
  end
structure Old_Datatype: OLD_DATATYPE
### theory "HOL-Library.Old_Datatype"
### 0.642s elapsed time, 3.828s cpu time, 0.000s GC time
Loading theory "HOL-Library.Countable" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Determinants" via "HOL-Analysis.Cartesian_Space" via "HOL-Analysis.Finite_Cartesian_Product" via "HOL-Library.Countable_Set")
instantiation
  prod :: (bot, bot) bot
  bot_prod == bot :: 'a \<times> 'b
### theory "HOL-Library.FuncSet"
### 0.747s elapsed time, 4.380s cpu time, 0.444s GC time
Loading theory "HOL-Analysis.Metric_Arith" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Abstract_Euclidean_Space" via "HOL-Analysis.Homotopy" via "HOL-Analysis.Path_Connected" via "HOL-Analysis.Starlike" via "HOL-Analysis.Convex_Euclidean_Space" via "HOL-Analysis.Topology_Euclidean_Space" via "HOL-Analysis.Elementary_Normed_Spaces" via "HOL-Analysis.Elementary_Metric_Spaces")
signature CANCEL_SIMPROCS =
  sig
    val diff_cancel: Proof.context -> cterm -> thm option
    val eq_cancel: Proof.context -> cterm -> thm option
    val less_cancel: Proof.context -> cterm -> thm option
    val less_eq_cancel: Proof.context -> cterm -> thm option
  end
structure Cancel_Simprocs: CANCEL_SIMPROCS
### theory "HOL-Library.Cancellation"
### 0.776s elapsed time, 4.576s cpu time, 0.444s GC time
Loading theory "HOL-Library.Multiset" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Determinants" via "HOL-Library.Permutations")
instantiation
  prod :: (Inf, Inf) Inf
  Inf_prod == Inf :: ('a \<times> 'b) set \<Rightarrow> 'a \<times> 'b
instantiation
  prod :: (Sup, Sup) Sup
  Sup_prod == Sup :: ('a \<times> 'b) set \<Rightarrow> 'a \<times> 'b
### theory "HOL-Library.Product_Order"
### 0.364s elapsed time, 2.108s cpu time, 0.444s GC time
Loading theory "HOL-Analysis.Inner_Product" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Convex" via "HOL-Analysis.Linear_Algebra" via "HOL-Analysis.Euclidean_Space")
### theory "HOL-Library.Set_Algebras"
### 0.378s elapsed time, 2.200s cpu time, 0.444s GC time
Loading theory "HOL-Analysis.L2_Norm" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Convex" via "HOL-Analysis.Linear_Algebra" via "HOL-Analysis.Euclidean_Space")
instantiation
  multiset :: (type) cancel_comm_monoid_add
  zero_multiset == zero_class.zero :: 'a multiset
  minus_multiset == minus ::
    'a multiset \<Rightarrow> 'a multiset \<Rightarrow> 'a multiset
  plus_multiset == plus ::
    'a multiset \<Rightarrow> 'a multiset \<Rightarrow> 'a multiset
### theory "HOL-Analysis.L2_Norm"
### 0.086s elapsed time, 0.516s cpu time, 0.000s GC time
Loading theory "HOL-Analysis.Operator_Norm" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Complex_Transcendental" via "HOL-Analysis.Complex_Analysis_Basics" via "HOL-Analysis.Derivative")
### theory "HOL-Analysis.Operator_Norm"
### 0.095s elapsed time, 0.572s cpu time, 0.000s GC time
Loading theory "HOL-Analysis.Poly_Roots" (required by "HOL-Analysis.Analysis")
### theory "HOL-Library.Phantom_Type"
### 0.822s elapsed time, 4.840s cpu time, 0.444s GC time
Loading theory "HOL-Library.Cardinality" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Determinants" via "HOL-Analysis.Cartesian_Space" via "HOL-Analysis.Finite_Cartesian_Product" via "HOL-Library.Numeral_Type")
### Additional type variable(s) in locale specification "countable": 'a
### theory "HOL-Analysis.Poly_Roots"
### 0.100s elapsed time, 0.596s cpu time, 0.000s GC time
Loading theory "HOL-Analysis.Product_Vector" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Convex" via "HOL-Analysis.Linear_Algebra" via "HOL-Analysis.Euclidean_Space")
### Additional type variable(s) in locale specification "CARD_1": 'a
class countable = type +
  assumes "ex_inj": "\<exists>to_nat. inj to_nat"
class CARD_1 = type +
  assumes "CARD_1": "CARD('a) = 1"
### Additional type variable(s) in locale specification "card2": 'a
Proofs for inductive predicate(s) "finite_item"
### Partially applied constant "Multiset.inf_subset_mset" on left hand side of equation, in theorem:
### semilattice_inf.Inf_fin (\<inter>#) (set (?x # ?xs)) \<equiv>
### fold (\<inter>#) ?xs ?x
  Proving monotonicity ...
  Proving the introduction rules ...
  Proving the elimination rules ...
  Proving the induction rule ...
  Proving the simplification rules ...
signature METRIC_ARITH =
  sig
    val metric_arith_tac: Proof.context -> int -> tactic
    val trace: bool Config.T
  end
structure MetricArith: METRIC_ARITH
### theory "HOL-Analysis.Metric_Arith"
### 0.660s elapsed time, 3.960s cpu time, 0.000s GC time
Loading theory "HOL-Library.Discrete" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Complex_Transcendental" via "HOL-Analysis.Complex_Analysis_Basics" via "HOL-Analysis.Derivative" via "HOL-Analysis.Uniform_Limit" via "HOL-Analysis.Summation_Tests")
### Partially applied constant "Multiset.sup_subset_mset" on left hand side of equation, in theorem:
### semilattice_sup.Sup_fin (\<union>#) (set (?x # ?xs)) \<equiv>
### fold (\<union>#) ?xs ?x
class card2 = finite +
  assumes "two_le_card": "2 \<le> CARD('a)"
class real_inner = dist_norm + real_vector + sgn_div_norm +
  uniformity_dist + open_uniformity +
  fixes inner :: "'a \<Rightarrow> 'a \<Rightarrow> real"
  assumes "inner_commute": "\<And>x y. inner x y = inner y x"
    and
    "inner_add_left": "\<And>x y z. inner (x + y) z = inner x z + inner y z"
    and
    "inner_scaleR_left":
      "\<And>r x y. inner (r *\<^sub>R x) y = r * inner x y"
    and "inner_ge_zero": "\<And>x. 0 \<le> inner x x"
    and "inner_eq_zero_iff": "\<And>x. (inner x x = 0) = (x = (0::'a))"
    and "norm_eq_sqrt_inner": "\<And>x. norm x = sqrt (inner x x)"
class finite_UNIV = type +
  fixes finite_UNIV :: "('a, bool) phantom"
  assumes "finite_UNIV": "finite_UNIV = Phantom('a) (finite UNIV)"
locale module_prod
  fixes s1 :: "'a \<Rightarrow> 'b \<Rightarrow> 'b"
    and s2 :: "'a \<Rightarrow> 'c \<Rightarrow> 'c"
  assumes "module_prod s1 s2"
### Rewrite rule not in simpset:
### Wellfounded.accp log_rel ?n1 \<Longrightarrow>
### log ?n1 \<equiv> if ?n1 < 2 then 0 else Suc (log (?n1 div 2))
Found termination order: "size <*mlex*> {}"
class card_UNIV = finite_UNIV +
  fixes card_UNIV :: "('a, nat) phantom"
  assumes "card_UNIV": "card_UNIV_class.card_UNIV = Phantom('a) CARD('a)"
instantiation
  nat :: card_UNIV
  card_UNIV_nat == card_UNIV_class.card_UNIV :: (nat, nat) phantom
  finite_UNIV_nat == finite_UNIV :: (nat, bool) phantom
instantiation
  int :: card_UNIV
  card_UNIV_int == card_UNIV_class.card_UNIV :: (int, nat) phantom
  finite_UNIV_int == finite_UNIV :: (int, bool) phantom
instantiation
  natural :: card_UNIV
  card_UNIV_natural == card_UNIV_class.card_UNIV :: (natural, nat) phantom
  finite_UNIV_natural == finite_UNIV :: (natural, bool) phantom
instantiation
  integer :: card_UNIV
  card_UNIV_integer == card_UNIV_class.card_UNIV :: (integer, nat) phantom
  finite_UNIV_integer == finite_UNIV :: (integer, bool) phantom
val old_countable_datatype_tac = fn: Proof.context -> int -> tactic
instantiation
  list :: (type) card_UNIV
  card_UNIV_list == card_UNIV_class.card_UNIV :: ('a list, nat) phantom
  finite_UNIV_list == finite_UNIV :: ('a list, bool) phantom
### theory "HOL-Library.Discrete"
### 0.218s elapsed time, 1.252s cpu time, 0.000s GC time
Loading theory "HOL-Library.Indicator_Function" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Connected" via "HOL-Analysis.Abstract_Topology_2")
locale vector_space_prod
  fixes
    s1 :: "'a \<Rightarrow> 'b \<Rightarrow> 'b"
      (infixr \<open>*a\<close> 75)
    and
    s2 :: "'a \<Rightarrow> 'c \<Rightarrow> 'c"
      (infixr \<open>*b\<close> 75)
  assumes "vector_space_prod (*a) (*b)"
instantiation
  unit :: card_UNIV
  card_UNIV_unit == card_UNIV_class.card_UNIV :: (unit, nat) phantom
  finite_UNIV_unit == finite_UNIV :: (unit, bool) phantom
Found termination order: "(\<lambda>p. size (fst p)) <*mlex*> {}"
instantiation
  bool :: card_UNIV
  card_UNIV_bool == card_UNIV_class.card_UNIV :: (bool, nat) phantom
  finite_UNIV_bool == finite_UNIV :: (bool, bool) phantom
instantiation
  char :: card_UNIV
  card_UNIV_char == card_UNIV_class.card_UNIV :: (char, nat) phantom
  finite_UNIV_char == finite_UNIV :: (char, bool) phantom
instantiation
  prod :: (real_vector, real_vector) real_vector
  scaleR_prod == scaleR ::
    real \<Rightarrow> 'a \<times> 'b \<Rightarrow> 'a \<times> 'b
instantiation
  prod :: (finite_UNIV, finite_UNIV) finite_UNIV
  finite_UNIV_prod == finite_UNIV :: ('a \<times> 'b, bool) phantom
instantiation
  prod :: (card_UNIV, card_UNIV) card_UNIV
  card_UNIV_prod == card_UNIV_class.card_UNIV ::
    ('a \<times> 'b, nat) phantom
instantiation
  sum :: (finite_UNIV, finite_UNIV) finite_UNIV
  finite_UNIV_sum == finite_UNIV :: ('a + 'b, bool) phantom
### ML warning (line 93 of "~~/src/HOL/Tools/BNF/bnf_lfp_countable.ML"):
### Pattern is not exhaustive.
### ML warning (line 139 of "~~/src/HOL/Tools/BNF/bnf_lfp_countable.ML"):
### Pattern is not exhaustive.
### ML warning (line 143 of "~~/src/HOL/Tools/BNF/bnf_lfp_countable.ML"):
### Matches are not exhaustive.
### ML warning (line 145 of "~~/src/HOL/Tools/BNF/bnf_lfp_countable.ML"):
### Matches are not exhaustive.
### ML warning (line 156 of "~~/src/HOL/Tools/BNF/bnf_lfp_countable.ML"):
### Pattern is not exhaustive.
signature BNF_LFP_COUNTABLE =
  sig
    val countable_datatype_tac: Proof.context -> tactic
    val derive_encode_injectives_thms:
       Proof.context -> string list -> thm list
  end
structure BNF_LFP_Countable: BNF_LFP_COUNTABLE
instantiation
  sum :: (card_UNIV, card_UNIV) card_UNIV
  card_UNIV_sum == card_UNIV_class.card_UNIV :: ('a + 'b, nat) phantom
val countable_datatype_tac = fn: Proof.context -> thm -> thm Seq.seq
val countable_tac = fn: Proof.context -> int -> tactic
instantiation
  prod :: (metric_space, metric_space) dist
  dist_prod == dist ::
    'a \<times> 'b \<Rightarrow> 'a \<times> 'b \<Rightarrow> real
instantiation
  fun :: (finite_UNIV, card_UNIV) finite_UNIV
  finite_UNIV_fun == finite_UNIV :: ('a \<Rightarrow> 'b, bool) phantom
instantiation
  fun :: (card_UNIV, card_UNIV) card_UNIV
  card_UNIV_fun == card_UNIV_class.card_UNIV ::
    ('a \<Rightarrow> 'b, nat) phantom
instantiation
  prod :: (metric_space, metric_space) uniformity_dist
  uniformity_prod == uniformity ::
    (('a \<times> 'b) \<times> 'a \<times> 'b) filter
instantiation
  option :: (finite_UNIV) finite_UNIV
  finite_UNIV_option == finite_UNIV :: ('a option, bool) phantom
instantiation
  prod :: (metric_space, metric_space) metric_space
instantiation
  option :: (card_UNIV) card_UNIV
  card_UNIV_option == card_UNIV_class.card_UNIV :: ('a option, nat) phantom
signature MULTISET_SIMPROCS =
  sig
    val subset_cancel_msets: Proof.context -> cterm -> thm option
    val subseteq_cancel_msets: Proof.context -> cterm -> thm option
  end
structure Multiset_Simprocs: MULTISET_SIMPROCS
instantiation
  String.literal :: card_UNIV
  card_UNIV_literal == card_UNIV_class.card_UNIV ::
    (String.literal, nat) phantom
  finite_UNIV_literal == finite_UNIV :: (String.literal, bool) phantom
instantiation
  set :: (finite_UNIV) finite_UNIV
  finite_UNIV_set == finite_UNIV :: ('a set, bool) phantom
instantiation
  prod :: (real_normed_vector, real_normed_vector) real_normed_vector
  sgn_prod == sgn :: 'a \<times> 'b \<Rightarrow> 'a \<times> 'b
  norm_prod == norm :: 'a \<times> 'b \<Rightarrow> real
instantiation
  set :: (card_UNIV) card_UNIV
  card_UNIV_set == card_UNIV_class.card_UNIV :: ('a set, nat) phantom
instantiation
  multiset :: (type) Inf
  Inf_multiset == Inf :: 'a multiset set \<Rightarrow> 'a multiset
instantiation
  Enum.finite_1 :: card_UNIV
  card_UNIV_finite_1 == card_UNIV_class.card_UNIV ::
    (Enum.finite_1, nat) phantom
  finite_UNIV_finite_1 == finite_UNIV :: (Enum.finite_1, bool) phantom
instantiation
  multiset :: (type) Sup
  Sup_multiset == Sup :: 'a multiset set \<Rightarrow> 'a multiset
instantiation
  Enum.finite_2 :: card_UNIV
  card_UNIV_finite_2 == card_UNIV_class.card_UNIV ::
    (Enum.finite_2, nat) phantom
  finite_UNIV_finite_2 == finite_UNIV :: (Enum.finite_2, bool) phantom
instantiation
  Enum.finite_3 :: card_UNIV
  card_UNIV_finite_3 == card_UNIV_class.card_UNIV ::
    (Enum.finite_3, nat) phantom
  finite_UNIV_finite_3 == finite_UNIV :: (Enum.finite_3, bool) phantom
instantiation
  Enum.finite_4 :: card_UNIV
  card_UNIV_finite_4 == card_UNIV_class.card_UNIV ::
    (Enum.finite_4, nat) phantom
  finite_UNIV_finite_4 == finite_UNIV :: (Enum.finite_4, bool) phantom
instantiation
  real :: real_inner
  inner_real == inner :: real \<Rightarrow> real \<Rightarrow> real
instantiation
  Enum.finite_5 :: card_UNIV
  card_UNIV_finite_5 == card_UNIV_class.card_UNIV ::
    (Enum.finite_5, nat) phantom
  finite_UNIV_finite_5 == finite_UNIV :: (Enum.finite_5, bool) phantom
instantiation
  complex :: real_inner
  inner_complex == inner :: complex \<Rightarrow> complex \<Rightarrow> real
instantiation
  multiset :: (type) size
  size_multiset == size :: 'a multiset \<Rightarrow> nat
### theory "HOL-Library.Indicator_Function"
### 0.474s elapsed time, 2.716s cpu time, 0.000s GC time
Loading theory "HOL-Library.Liminf_Limsup" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Complex_Transcendental" via "HOL-Analysis.Complex_Analysis_Basics" via "HOL-Analysis.Derivative" via "HOL-Analysis.Uniform_Limit" via "HOL-Analysis.Summation_Tests" via "HOL-Library.Extended_Real")
bundle inner_syntax
bundle no_inner_syntax
### theory "HOL-Analysis.Inner_Product"
### 1.246s elapsed time, 7.288s cpu time, 0.000s GC time
Loading theory "HOL-Library.Nonpos_Ints" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Complex_Transcendental" via "HOL-Analysis.Complex_Analysis_Basics")
### Code generator: dropping subsumed code equation
### List.coset [] \<subseteq> set [] \<equiv> False
### theory "HOL-Library.Countable"
### 1.755s elapsed time, 10.092s cpu time, 1.312s GC time
Loading theory "HOL-Library.Countable_Set" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Determinants" via "HOL-Analysis.Cartesian_Space" via "HOL-Analysis.Finite_Cartesian_Product")
locale comp_fun_commute
  fixes f :: "'a \<Rightarrow> 'b \<Rightarrow> 'b"
  assumes "comp_fun_commute f"
locale finite_dimensional_vector_space_prod
  fixes
    s1 :: "'a \<Rightarrow> 'b \<Rightarrow> 'b"
      (infixr \<open>*a\<close> 75)
    and
    s2 :: "'a \<Rightarrow> 'c \<Rightarrow> 'c"
      (infixr \<open>*b\<close> 75)
    and B1 :: "'b set"
    and B2 :: "'c set"
  assumes "finite_dimensional_vector_space_prod (*a) (*b) B1 B2"
### theory "HOL-Library.Cardinality"
### 1.392s elapsed time, 7.972s cpu time, 0.868s GC time
Loading theory "HOL-Library.Numeral_Type" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Determinants" via "HOL-Analysis.Cartesian_Space" via "HOL-Analysis.Finite_Cartesian_Product")
consts
  mset :: "'a list \<Rightarrow> 'a multiset"
### theory "HOL-Analysis.Product_Vector"
### 1.339s elapsed time, 7.656s cpu time, 0.868s GC time
Loading theory "HOL-Analysis.Euclidean_Space" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Convex" via "HOL-Analysis.Linear_Algebra")
### theory "HOL-Library.Nonpos_Ints"
### 0.417s elapsed time, 2.316s cpu time, 0.868s GC time
Loading theory "HOL-Library.Periodic_Fun" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Complex_Transcendental")
locale periodic_fun
  fixes f :: "'a \<Rightarrow> 'b"
    and g :: "'a \<Rightarrow> 'a \<Rightarrow> 'a"
    and gm :: "'a \<Rightarrow> 'a \<Rightarrow> 'a"
    and g1 :: "'a \<Rightarrow> 'a"
    and gn1 :: "'a \<Rightarrow> 'a"
  assumes "periodic_fun f g gm g1 gn1"
locale periodic_fun_simple
  fixes f :: "'a \<Rightarrow> 'b"
    and period :: "'a"
  assumes "periodic_fun_simple f period"
locale periodic_fun_simple'
  fixes f :: "'a \<Rightarrow> 'b"
  assumes "periodic_fun_simple' f"
### theory "HOL-Library.Periodic_Fun"
### 0.137s elapsed time, 0.828s cpu time, 0.000s GC time
Loading theory "HOL-Library.Sum_of_Squares" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Abstract_Euclidean_Space" via "HOL-Analysis.Homotopy" via "HOL-Analysis.Path_Connected" via "HOL-Analysis.Starlike" via "HOL-Analysis.Convex_Euclidean_Space" via "HOL-Analysis.Topology_Euclidean_Space" via "HOL-Analysis.Norm_Arith")
instantiation
  num1 :: CARD_1
instantiation
  num1 :: {comm_monoid_mult,numeral,comm_ring}
  uminus_num1 == uminus :: num1 \<Rightarrow> num1
  zero_num1 == zero_class.zero :: num1
  minus_num1 == minus :: num1 \<Rightarrow> num1 \<Rightarrow> num1
  plus_num1 == plus :: num1 \<Rightarrow> num1 \<Rightarrow> num1
  one_num1 == one_class.one :: num1
  times_num1 == times :: num1 \<Rightarrow> num1 \<Rightarrow> num1
class linorder = order +
  assumes "linear": "\<And>x y. x \<le> y \<or> y \<le> x"
instantiation
  num1 :: linorder
  less_eq_num1 == less_eq :: num1 \<Rightarrow> num1 \<Rightarrow> bool
  less_num1 == less :: num1 \<Rightarrow> num1 \<Rightarrow> bool
locale mod_type
  fixes n :: "int"
    and Rep :: "'a \<Rightarrow> int"
    and Abs :: "int \<Rightarrow> 'a"
  assumes "mod_type n Rep Abs"
locale mod_ring
  fixes n :: "int"
    and Rep :: "'a \<Rightarrow> int"
    and Abs :: "int \<Rightarrow> 'a"
  assumes "mod_ring n Rep Abs"
### Rule already declared as safe introduction (intro!)
### True
### Ignoring duplicate introduction (intro)
### True
instantiation
  bit0 :: (finite) {minus,one,plus,times,uminus,zero}
  bit1 :: (finite) {minus,one,plus,times,uminus,zero}
  zero_bit0 == zero_class.zero :: 'a bit0
  uminus_bit0 == uminus :: 'a bit0 \<Rightarrow> 'a bit0
  times_bit0 == times :: 'a bit0 \<Rightarrow> 'a bit0 \<Rightarrow> 'a bit0
  plus_bit0 == plus :: 'a bit0 \<Rightarrow> 'a bit0 \<Rightarrow> 'a bit0
  one_bit0 == one_class.one :: 'a bit0
  minus_bit0 == minus :: 'a bit0 \<Rightarrow> 'a bit0 \<Rightarrow> 'a bit0
  zero_bit1 == zero_class.zero :: 'a bit1
  uminus_bit1 == uminus :: 'a bit1 \<Rightarrow> 'a bit1
  times_bit1 == times :: 'a bit1 \<Rightarrow> 'a bit1 \<Rightarrow> 'a bit1
  plus_bit1 == plus :: 'a bit1 \<Rightarrow> 'a bit1 \<Rightarrow> 'a bit1
  one_bit1 == one_class.one :: 'a bit1
  minus_bit1 == minus :: 'a bit1 \<Rightarrow> 'a bit1 \<Rightarrow> 'a bit1
locale comm_monoid_mset
  fixes
    f :: "'a \<Rightarrow> 'a \<Rightarrow> 'a"
      (infixl \<open>\<^bold>*\<close> 70)
    and z :: "'a"  (\<open>\<^bold>1\<close>)
  assumes "comm_monoid_mset (\<^bold>*) \<^bold>1"
### theory "HOL-Library.Liminf_Limsup"
### 0.716s elapsed time, 4.124s cpu time, 0.868s GC time
class comm_monoid_add = ab_semigroup_add + monoid_add +
  assumes "add_0": "\<And>a. (0::'a) + a = a"
### theory "HOL-Library.Countable_Set"
### 0.496s elapsed time, 2.996s cpu time, 0.000s GC time
Loading theory "HOL-Library.Countable_Complete_Lattices" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Complex_Transcendental" via "HOL-Analysis.Complex_Analysis_Basics" via "HOL-Analysis.Derivative" via "HOL-Analysis.Uniform_Limit" via "HOL-Analysis.Summation_Tests" via "HOL-Library.Extended_Real" via "HOL-Library.Extended_Nat" via "HOL-Library.Order_Continuity")
Loading theory "HOL-Library.Set_Idioms" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Connected" via "HOL-Analysis.Abstract_Topology_2" via "HOL-Analysis.Elementary_Topology")
instantiation
  bit0 :: (finite) linorder
  bit1 :: (finite) linorder
  less_eq_bit0 == less_eq ::
    'a bit0 \<Rightarrow> 'a bit0 \<Rightarrow> bool
  less_bit0 == less :: 'a bit0 \<Rightarrow> 'a bit0 \<Rightarrow> bool
  less_eq_bit1 == less_eq ::
    'a bit1 \<Rightarrow> 'a bit1 \<Rightarrow> bool
  less_bit1 == less :: 'a bit1 \<Rightarrow> 'a bit1 \<Rightarrow> bool
class comm_monoid_add = ab_semigroup_add + monoid_add +
  assumes "add_0": "\<And>a. (0::'a) + a = a"
class canonically_ordered_monoid_add = ordered_comm_monoid_add +
  assumes "le_iff_add": "\<And>a b. (a \<le> b) = (\<exists>c. b = a + c)"
instantiation
  num0 :: equal
  equal_num0 == equal_class.equal ::
    num0 \<Rightarrow> num0 \<Rightarrow> bool
instantiation
  num1 :: equal
  equal_num1 == equal_class.equal ::
    num1 \<Rightarrow> num1 \<Rightarrow> bool
instantiation
  num1 :: enum
  enum_num1 == enum_class.enum :: num1 list
  enum_all_num1 == enum_class.enum_all ::
    (num1 \<Rightarrow> bool) \<Rightarrow> bool
  enum_ex_num1 == enum_class.enum_ex ::
    (num1 \<Rightarrow> bool) \<Rightarrow> bool
instantiation
  num0 :: card_UNIV
  num1 :: card_UNIV
  card_UNIV_num0 == card_UNIV_class.card_UNIV :: (num0, nat) phantom
  finite_UNIV_num0 == finite_UNIV :: (num0, bool) phantom
  card_UNIV_num1 == card_UNIV_class.card_UNIV :: (num1, nat) phantom
  finite_UNIV_num1 == finite_UNIV :: (num1, bool) phantom
### theory "HOL-Library.Set_Idioms"
### 0.229s elapsed time, 1.380s cpu time, 0.000s GC time
Loading theory "HOL-Analysis.Abstract_Topology" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Connected" via "HOL-Analysis.Abstract_Topology_2")
instantiation
  bit0 :: (finite) equal
  bit1 :: (finite) equal
  equal_bit0 == equal_class.equal ::
    'a bit0 \<Rightarrow> 'a bit0 \<Rightarrow> bool
  equal_bit1 == equal_class.equal ::
    'a bit1 \<Rightarrow> 'a bit1 \<Rightarrow> bool
instantiation
  bit0 :: (finite) enum
  enum_bit0 == enum_class.enum :: 'a bit0 list
  enum_all_bit0 == enum_class.enum_all ::
    ('a bit0 \<Rightarrow> bool) \<Rightarrow> bool
  enum_ex_bit0 == enum_class.enum_ex ::
    ('a bit0 \<Rightarrow> bool) \<Rightarrow> bool
instantiation
  bit1 :: (finite) enum
  enum_bit1 == enum_class.enum :: 'a bit1 list
  enum_all_bit1 == enum_class.enum_all ::
    ('a bit1 \<Rightarrow> bool) \<Rightarrow> bool
  enum_ex_bit1 == enum_class.enum_ex ::
    ('a bit1 \<Rightarrow> bool) \<Rightarrow> bool
instantiation
  bit0 :: (finite) finite_UNIV
  bit1 :: (finite) finite_UNIV
  finite_UNIV_bit0 == finite_UNIV :: ('a bit0, bool) phantom
  finite_UNIV_bit1 == finite_UNIV :: ('a bit1, bool) phantom
instantiation
  bit0 :: ({card_UNIV,finite}) card_UNIV
  bit1 :: ({card_UNIV,finite}) card_UNIV
  card_UNIV_bit0 == card_UNIV_class.card_UNIV :: ('a bit0, nat) phantom
  card_UNIV_bit1 == card_UNIV_class.card_UNIV :: ('a bit1, nat) phantom
### theory "HOL-Library.Numeral_Type"
### 0.770s elapsed time, 4.640s cpu time, 0.000s GC time
Loading theory "HOL-Analysis.Continuum_Not_Denumerable" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Abstract_Euclidean_Space" via "HOL-Analysis.Homotopy")
class euclidean_space = real_inner +
  fixes Basis :: "'a set"
  assumes "nonempty_Basis": "Basis \<noteq> {}"
  assumes "finite_Basis": "finite Basis"
  assumes
    "inner_Basis":
      "\<And>u v.
          \<lbrakk>u \<in> Basis; v \<in> Basis\<rbrakk>
          \<Longrightarrow> inner u v = (if u = v then 1 else 0)"
  assumes
    "euclidean_all_zero_iff":
      "\<And>x. (\<forall>u\<in>Basis. inner x u = 0) = (x = (0::'a))"
class comm_monoid_mult = ab_semigroup_mult + monoid_mult + dvd +
  assumes "mult_1": "\<And>a. (1::'a) * a = a"
class countable_complete_lattice = Inf + Sup + lattice + bot + top +
  assumes
    "ccInf_lower":
      "\<And>A x.
          \<lbrakk>countable A; x \<in> A\<rbrakk>
          \<Longrightarrow> Inf A \<le> x"
  assumes
    "ccInf_greatest":
      "\<And>A z.
          \<lbrakk>countable A;
           \<And>x. x \<in> A \<Longrightarrow> z \<le> x\<rbrakk>
          \<Longrightarrow> z \<le> Inf A"
  assumes
    "ccSup_upper":
      "\<And>A x.
          \<lbrakk>countable A; x \<in> A\<rbrakk>
          \<Longrightarrow> x \<le> Sup A"
  assumes
    "ccSup_least":
      "\<And>A z.
          \<lbrakk>countable A;
           \<And>x. x \<in> A \<Longrightarrow> x \<le> z\<rbrakk>
          \<Longrightarrow> Sup A \<le> z"
  assumes "ccInf_empty": "Inf {} = top"
  assumes "ccSup_empty": "Sup {} = bot"
### theory "HOL-Analysis.Continuum_Not_Denumerable"
### 0.411s elapsed time, 2.372s cpu time, 0.688s GC time
Loading theory "HOL-Analysis.Elementary_Topology" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Connected" via "HOL-Analysis.Abstract_Topology_2")
class linorder = order +
  assumes "linear": "\<And>x y. x \<le> y \<or> y \<le> x"
instantiation
  multiset :: (preorder) order
  less_eq_multiset == less_eq ::
    'a multiset \<Rightarrow> 'a multiset \<Rightarrow> bool
  less_multiset == less ::
    'a multiset \<Rightarrow> 'a multiset \<Rightarrow> bool
instantiation
  multiset :: (preorder) ordered_ab_semigroup_add
Proofs for inductive predicate(s) "pw_leq"
  Proving monotonicity ...
  Proving the introduction rules ...
  Proving the elimination rules ...
  Proving the induction rule ...
  Proving the simplification rules ...
instantiation
  real :: euclidean_space
  Basis_real == Basis :: real set
class topological_space = open +
  assumes "open_UNIV": "open UNIV"
  assumes
    "open_Int":
      "\<And>S T.
          \<lbrakk>open S; open T\<rbrakk>
          \<Longrightarrow> open (S \<inter> T)"
  assumes
    "open_Union": "\<And>K. Ball K open \<Longrightarrow> open (\<Union> K)"
instantiation
  complex :: euclidean_space
  Basis_complex == Basis :: complex set
class countable_complete_distrib_lattice = countable_complete_lattice +
  assumes
    "sup_ccInf":
      "\<And>B a.
          countable B \<Longrightarrow> sup a (Inf B) = Inf (sup a ` B)"
  assumes
    "inf_ccSup":
      "\<And>B a.
          countable B \<Longrightarrow> inf a (Sup B) = Sup (inf a ` B)"
instantiation
  prod :: (real_inner, real_inner) real_inner
  inner_prod == inner ::
    'a \<times> 'b \<Rightarrow> 'a \<times> 'b \<Rightarrow> real
instantiation
  prod :: (euclidean_space, euclidean_space) euclidean_space
  Basis_prod == Basis :: ('a \<times> 'b) set
locale countable_basis
  fixes p :: "'a set \<Rightarrow> bool"
    and B :: "'a set set"
  assumes "countable_basis p B"
### theory "HOL-Analysis.Euclidean_Space"
### 2.057s elapsed time, 12.256s cpu time, 0.688s GC time
Loading theory "HOL-Analysis.Finite_Cartesian_Product" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Determinants" via "HOL-Analysis.Cartesian_Space")
Found termination order: "(\<lambda>p. length (fst p)) <*mlex*> {}"
class second_countable_topology = topological_space +
  assumes
    "ex_countable_subbasis":
      "\<exists>B. countable B \<and> open = generate_topology B"
instantiation
  multiset :: (equal) equal
  equal_multiset == equal_class.equal ::
    'a multiset \<Rightarrow> 'a multiset \<Rightarrow> bool
instantiation
  multiset :: (random) random
  random_multiset == random_class.random ::
    natural
    \<Rightarrow> natural \<times> natural
                  \<Rightarrow> ('a multiset \<times>
                                 (unit \<Rightarrow> term)) \<times>
                                natural \<times> natural
instantiation
  multiset :: (full_exhaustive) full_exhaustive
  full_exhaustive_multiset == full_exhaustive_class.full_exhaustive ::
    ('a multiset \<times> (unit \<Rightarrow> term)
     \<Rightarrow> (bool \<times> term list) option)
    \<Rightarrow> natural \<Rightarrow> (bool \<times> term list) option
Proofs for inductive predicate(s) "pred_mset"
  Proving monotonicity ...
  Proving the introduction rules ...
  Proving the elimination rules ...
  Proving the induction rule ...
  Proving the simplification rules ...
### ML warning (line 379 of "~~/src/HOL/Library/Sum_of_Squares/positivstellensatz.ML"):
### Pattern is not exhaustive.
signature FUNC =
  sig
    exception DUP of key
    exception SAME
    exception UNDEF of key
    val apply: 'a table -> key -> 'a
    val applyd: 'a table -> (key -> 'a) -> key -> 'a
    val choose: 'a table -> key * 'a
    val combine:
       ('a -> 'a -> 'a) -> ('a -> bool) -> 'a table -> 'a table -> 'a table
    val cons_list: key * 'a -> 'a list table -> 'a list table
    val default: key * 'a -> 'a table -> 'a table
    val defined: 'a table -> key -> bool
    val delete: key -> 'a table -> 'a table
    val delete_safe: key -> 'a table -> 'a table
    val dest: 'a table -> (key * 'a) list
    val dest_list: 'a list table -> (key * 'a) list
    val dom: 'a table -> key list
    val empty: 'a table
    val exists: (key * 'a -> bool) -> 'a table -> bool
    val fold: (key * 'a -> 'b -> 'b) -> 'a table -> 'b -> 'b
    val fold_rev: (key * 'a -> 'b -> 'b) -> 'a table -> 'b -> 'b
    val forall: (key * 'a -> bool) -> 'a table -> bool
    val get_first: (key * 'a -> 'b option) -> 'a table -> 'b option
    val insert: ('a * 'a -> bool) -> key * 'a -> 'a table -> 'a table
    val insert_list:
       ('a * 'a -> bool) -> key * 'a -> 'a list table -> 'a list table
    val insert_set: key -> set -> set
    val is_empty: 'a table -> bool
    val is_single: 'a table -> bool
    val join: (key -> 'a * 'a -> 'a) -> 'a table * 'a table -> 'a table
    type key
    val keys: 'a table -> key list
    val lookup: 'a table -> key -> 'a option
    val lookup_key: 'a table -> key -> (key * 'a) option
    val lookup_list: 'a list table -> key -> 'a list
    val make: (key * 'a) list -> 'a table
    val make_list: (key * 'a) list -> 'a list table
    val make_set: key list -> set
    val map: (key -> 'a -> 'b) -> 'a table -> 'b table
    val map_default: key * 'a -> ('a -> 'a) -> 'a table -> 'a table
    val map_entry: key -> ('a -> 'a) -> 'a table -> 'a table
    val max: 'a table -> (key * 'a) option
    val member: ('a * 'b -> bool) -> 'b table -> key * 'a -> bool
    val merge: ('a * 'a -> bool) -> 'a table * 'a table -> 'a table
    val merge_list:
       ('a * 'a -> bool) -> 'a list table * 'a list table -> 'a list table
    val min: 'a table -> (key * 'a) option
    val onefunc: key * 'a -> 'a table
    val remove: ('a * 'b -> bool) -> key * 'a -> 'b table -> 'b table
    val remove_list:
       ('a * 'b -> bool) -> key * 'a -> 'b list table -> 'b list table
    val remove_set: key -> set -> set
    type set = unit table
    type 'a table
    val tryapplyd: 'a table -> key -> 'a -> 'a
    val update: key * 'a -> 'a table -> 'a table
    val update_list:
       ('a * 'a -> bool) -> key * 'a -> 'a list table -> 'a list table
    val update_new: key * 'a -> 'a table -> 'a table
    val updatep: (key * 'a -> bool) -> key * 'a -> 'a table -> 'a table
  end
functor FuncFun (Key: KEY): FUNC
signature REAL_ARITH =
  sig
    type cert_conv = cterm -> thm * pss_tree
    val cterm_of_rat: Rat.rat -> cterm
    val dest_ratconst: cterm -> Rat.rat
    val gen_gen_real_arith:
       Proof.context ->
         (Rat.rat -> cterm) * conv * conv * conv * conv * conv * conv *
         conv * conv * conv * prover
           -> cert_conv
    val gen_prover_real_arith: Proof.context -> prover -> cert_conv
    val gen_real_arith:
       Proof.context ->
         (Rat.rat -> cterm) * conv * conv * conv * conv * conv * conv *
         conv * prover
           -> cert_conv
    val is_ratconst: cterm -> bool
    datatype positivstellensatz
    =
         Axiom_eq of int
       | Axiom_le of int
       | Axiom_lt of int
       | Eqmul of FuncUtil.poly * positivstellensatz
       | Product of positivstellensatz * positivstellensatz
       | Rational_eq of Rat.rat
       | Rational_le of Rat.rat
       | Rational_lt of Rat.rat
       | Square of FuncUtil.poly
       | Sum of positivstellensatz * positivstellensatz
    type prover =
       tree_choice list ->
         (thm list * thm list * thm list -> positivstellensatz -> thm) ->
           thm list * thm list * thm list -> thm * pss_tree
    datatype pss_tree
    = Branch of pss_tree * pss_tree | Cert of positivstellensatz | Trivial
    val real_linear_prover:
       (thm list * thm list * thm list -> positivstellensatz -> thm) ->
         thm list * thm list * thm list -> thm * pss_tree
    datatype tree_choice = Left | Right
  end
structure FuncUtil:
  sig
    structure Ctermfunc: FUNC
    structure Intfunc: FUNC
    structure Intpairfunc: FUNC
    structure Monomialfunc: FUNC
    structure Ratfunc: FUNC
    structure Symfunc: FUNC
    structure Termfunc: FUNC
    val dest_monomial: 'a Ctermfunc.table -> (cterm * 'a) list
    type monomial = int Ctermfunc.table
    val monomial_ord: int Ctermfunc.table * int Ctermfunc.table -> order
    val monomial_order: int Ctermfunc.table * int Ctermfunc.table -> order
    type poly = Rat.rat Monomialfunc.table
  end
structure RealArith: REAL_ARITH
Proofs for inductive predicate(s) "rel_mset'"
  Proving monotonicity ...
  Proving the introduction rules ...
  Proving the elimination rules ...
  Proving the induction rule ...
  Proving the simplification rules ...
### Ignoring duplicate rewrite rule:
### homeomorphic_map ?X1 ?Y1 id \<equiv> ?Y1 = ?X1
### theory "HOL-Library.Countable_Complete_Lattices"
### 2.508s elapsed time, 14.844s cpu time, 1.376s GC time
Loading theory "HOL-Analysis.Linear_Algebra" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Convex")
### theory "HOL-Library.Multiset"
### 4.623s elapsed time, 27.172s cpu time, 2.244s GC time
Loading theory "HOL-Computational_Algebra.Factorial_Ring" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Jordan_Curve" via "HOL-Analysis.Arcwise_Connected" via "HOL-Computational_Algebra.Primes" via "HOL-Computational_Algebra.Euclidean_Algorithm")
signature POSITIVSTELLENSATZ_TOOLS =
  sig
    val print_cert: RealArith.pss_tree -> string
    val read_cert: Proof.context -> string -> RealArith.pss_tree
  end
structure Positivstellensatz_Tools: POSITIVSTELLENSATZ_TOOLS
bundle vec_syntax
bundle no_vec_syntax
instantiation
  vec :: (zero, finite) zero
  zero_vec == zero_class.zero :: ('a, 'b) vec
instantiation
  vec :: (plus, finite) plus
  plus_vec == plus ::
    ('a, 'b) vec \<Rightarrow> ('a, 'b) vec \<Rightarrow> ('a, 'b) vec
instantiation
  vec :: (minus, finite) minus
  minus_vec == minus ::
    ('a, 'b) vec \<Rightarrow> ('a, 'b) vec \<Rightarrow> ('a, 'b) vec
instantiation
  vec :: (uminus, finite) uminus
  uminus_vec == uminus :: ('a, 'b) vec \<Rightarrow> ('a, 'b) vec
instantiation
  vec :: (times, finite) times
  times_vec == times ::
    ('a, 'b) vec \<Rightarrow> ('a, 'b) vec \<Rightarrow> ('a, 'b) vec
signature SUM_OF_SQUARES =
  sig
    exception Failure of string
    val debug: bool Config.T
    val debug_message: Proof.context -> (unit -> string) -> unit
    datatype proof_method
    = Certificate of RealArith.pss_tree | Prover of string -> string
    val sos_tac:
       (RealArith.pss_tree -> unit) ->
         proof_method -> Proof.context -> int -> tactic
    val trace: bool Config.T
    val trace_message: Proof.context -> (unit -> string) -> unit
  end
structure Sum_of_Squares: SUM_OF_SQUARES
instantiation
  vec :: (one, finite) one
  one_vec == one_class.one :: ('a, 'b) vec
class real_inner = real_normed_vector +
  fixes inner :: "'a \<Rightarrow> 'a \<Rightarrow> real"
  assumes "inner_commute": "\<And>x y. x \<bullet> y = y \<bullet> x"
    and
    "inner_add_left":
      "\<And>x y z. (x + y) \<bullet> z = x \<bullet> z + y \<bullet> z"
    and
    "inner_scaleR_left":
      "\<And>r x y. r *\<^sub>R x \<bullet> y = r * (x \<bullet> y)"
    and "inner_ge_zero": "\<And>x. 0 \<le> x \<bullet> x"
    and "inner_eq_zero_iff": "\<And>x. (x \<bullet> x = 0) = (x = (0::'a))"
    and "norm_eq_sqrt_inner": "\<And>x. norm x = sqrt (x \<bullet> x)"
instantiation
  vec :: (ord, finite) ord
  less_eq_vec == less_eq ::
    ('a, 'b) vec \<Rightarrow> ('a, 'b) vec \<Rightarrow> bool
  less_vec == less ::
    ('a, 'b) vec \<Rightarrow> ('a, 'b) vec \<Rightarrow> bool
signature SOS_WRAPPER =
  sig val sos_tac: Proof.context -> string option -> int -> tactic end
structure SOS_Wrapper: SOS_WRAPPER
### theory "HOL-Library.Sum_of_Squares"
### 3.393s elapsed time, 20.036s cpu time, 1.948s GC time
Loading theory "HOL-Library.Permutations" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Determinants")
instantiation
  vec :: (real_vector, finite) real_vector
  scaleR_vec == scaleR ::
    real \<Rightarrow> ('a, 'b) vec \<Rightarrow> ('a, 'b) vec
instantiation
  vec :: (topological_space, finite) topological_space
  open_vec == open :: ('a, 'b) vec set \<Rightarrow> bool
instantiation
  vec :: (metric_space, finite) dist
  dist_vec == dist ::
    ('a, 'b) vec \<Rightarrow> ('a, 'b) vec \<Rightarrow> real
instantiation
  vec :: (metric_space, finite) uniformity_dist
  uniformity_vec == uniformity ::
    (('a, 'b) vec \<times> ('a, 'b) vec) filter
Proofs for inductive predicate(s) "generate_topology_on"
instantiation
  vec :: (metric_space, finite) metric_space
  Proving monotonicity ...
  Proving the introduction rules ...
  Proving the elimination rules ...
  Proving the induction rule ...
  Proving the simplification rules ...
instantiation
  vec :: (real_normed_vector, finite) real_normed_vector
  sgn_vec == sgn :: ('a, 'b) vec \<Rightarrow> ('a, 'b) vec
  norm_vec == norm :: ('a, 'b) vec \<Rightarrow> real
### theory "HOL-Analysis.Elementary_Topology"
### 2.542s elapsed time, 15.012s cpu time, 1.260s GC time
Loading theory "HOL-Library.Order_Continuity" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Complex_Transcendental" via "HOL-Analysis.Complex_Analysis_Basics" via "HOL-Analysis.Derivative" via "HOL-Analysis.Uniform_Limit" via "HOL-Analysis.Summation_Tests" via "HOL-Library.Extended_Real" via "HOL-Library.Extended_Nat")
instantiation
  vec :: (real_inner, finite) real_inner
  inner_vec == inner ::
    ('a, 'b) vec \<Rightarrow> ('a, 'b) vec \<Rightarrow> real
instantiation
  vec :: (euclidean_space, finite) euclidean_space
  Basis_vec == Basis :: ('a, 'b) vec set
class normalization_semidom = algebraic_semidom +
  semidom_divide_unit_factor +
  fixes normalize :: "'a \<Rightarrow> 'a"
  assumes
    "unit_factor_mult_normalize": "\<And>a. unit_factor a * normalize a = a"
    and "normalize_0": "normalize (0::'a) = (0::'a)"
### Ignoring duplicate rewrite rule:
### vec_lambda ?g1 $ ?i1 \<equiv> ?g1 ?i1
Proofs for inductive predicate(s) "swapidseq"
  Proving monotonicity ...
  Proving the introduction rules ...
  Proving the elimination rules ...
  Proving the induction rule ...
  Proving the simplification rules ...
### theory "HOL-Analysis.Abstract_Topology"
### 3.317s elapsed time, 19.584s cpu time, 1.948s GC time
Loading theory "HOL-Analysis.Abstract_Limits" (required by "HOL-Analysis.Analysis")
### theory "HOL-Analysis.Linear_Algebra"
### 1.250s elapsed time, 7.404s cpu time, 0.572s GC time
Loading theory "HOL-Analysis.Convex" (required by "HOL-Analysis.Analysis")
### theory "HOL-Analysis.Abstract_Limits"
### 0.232s elapsed time, 1.404s cpu time, 0.000s GC time
Loading theory "HOL-Analysis.Abstract_Topology_2" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Connected")
Found termination order: "(\<lambda>p. size_list size (fst p)) <*mlex*> {}"
class semiring_gcd = gcd + normalization_semidom +
  assumes "gcd_dvd1": "\<And>a b. gcd a b dvd a"
    and "gcd_dvd2": "\<And>a b. gcd a b dvd b"
    and
    "gcd_greatest":
      "\<And>c a b.
          \<lbrakk>c dvd a; c dvd b\<rbrakk>
          \<Longrightarrow> c dvd gcd a b"
    and "normalize_gcd": "\<And>a b. normalize (gcd a b) = gcd a b"
    and "lcm_gcd": "\<And>a b. lcm a b = normalize (a * b) div gcd a b"
### theory "HOL-Analysis.Finite_Cartesian_Product"
### 2.244s elapsed time, 13.264s cpu time, 1.260s GC time
Loading theory "HOL-Analysis.Cartesian_Space" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Determinants")
### theory "HOL-Library.Permutations"
### 0.796s elapsed time, 4.808s cpu time, 0.000s GC time
Loading theory "HOL-Analysis.Norm_Arith" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Abstract_Euclidean_Space" via "HOL-Analysis.Homotopy" via "HOL-Analysis.Path_Connected" via "HOL-Analysis.Starlike" via "HOL-Analysis.Convex_Euclidean_Space" via "HOL-Analysis.Topology_Euclidean_Space")
### theory "HOL-Library.Order_Continuity"
### 0.605s elapsed time, 3.664s cpu time, 0.000s GC time
Loading theory "HOL-Library.Extended_Nat" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Complex_Transcendental" via "HOL-Analysis.Complex_Analysis_Basics" via "HOL-Analysis.Derivative" via "HOL-Analysis.Uniform_Limit" via "HOL-Analysis.Summation_Tests" via "HOL-Library.Extended_Real")
class infinity = type +
  fixes infinity :: "'a"
instantiation
  enat :: infinity
  infinity_enat == infinity :: enat
Proofs for inductive predicate(s) "rec_set_enat"
  Proving monotonicity ...
  Proving the introduction rules ...
  Proving the elimination rules ...
  Proving the simplification rules ...
### ML warning (line 103 of "~~/src/HOL/Analysis/normarith.ML"):
### Matches are not exhaustive.
### ML warning (line 347 of "~~/src/HOL/Analysis/normarith.ML"):
### Value identifier (instantiate_cterm') has not been referenced.
signature NORM_ARITH =
  sig
    val norm_arith: Proof.context -> conv
    val norm_arith_tac: Proof.context -> int -> tactic
  end
structure NormArith: NORM_ARITH
### theory "HOL-Analysis.Norm_Arith"
### 0.548s elapsed time, 3.132s cpu time, 0.800s GC time
### No equation for constructor "Extended_Nat.infinity_class.infinity"
### in definition of function "the_enat"
consts
  the_enat :: "enat \<Rightarrow> nat"
instantiation
  enat :: zero_neq_one
  one_enat == one_class.one :: enat
  zero_enat == zero_class.zero :: enat
instantiation
  enat :: comm_monoid_add
  plus_enat == plus :: enat \<Rightarrow> enat \<Rightarrow> enat
instantiation
  enat :: {comm_semiring_1,semiring_no_zero_divisors}
  times_enat == times :: enat \<Rightarrow> enat \<Rightarrow> enat
instantiation
  enat :: minus
  minus_enat == minus :: enat \<Rightarrow> enat \<Rightarrow> enat
instantiation
  enat :: linordered_ab_semigroup_add
  less_eq_enat == less_eq :: enat \<Rightarrow> enat \<Rightarrow> bool
  less_enat == less :: enat \<Rightarrow> enat \<Rightarrow> bool
locale linear_first_finite_dimensional_vector_space
  fixes
    scaleB :: "'a \<Rightarrow> 'b \<Rightarrow> 'b"
      (infixr \<open>*b\<close> 75)
    and
    scaleC :: "'a \<Rightarrow> 'c \<Rightarrow> 'c"
      (infixr \<open>*c\<close> 75)
    and BasisB :: "'b set"
    and f :: "'b \<Rightarrow> 'c"
  assumes "linear_first_finite_dimensional_vector_space (*b) (*c) BasisB f"
class factorial_semiring = normalization_semidom +
  assumes
    "prime_factorization_exists":
      "\<And>x.
          x \<noteq> (0::'a) \<Longrightarrow>
          \<exists>A.
             (\<forall>x. x \<in># A \<longrightarrow> prime_elem x) \<and>
             prod_mset A = normalize x"
instantiation
  enat :: {order_bot,order_top}
  top_enat == top :: enat
  bot_enat == bot :: enat
structure Cancel_Enat_Common:
  sig
    val dest_sum: term -> term list
    val dest_summing: term * term list -> term list
    val find_first: term -> term list -> term list
    val find_first_t: term list -> term -> term list -> term list
    val mk_eq: term * term -> term
    val mk_sum: typ -> term list -> term
    val norm_ss: simpset
    val norm_tac: Proof.context -> tactic
    val simplify_meta_eq: Proof.context -> thm -> thm -> thm
    val trans_tac: Proof.context -> thm option -> tactic
  end
structure Eq_Enat_Cancel:
  sig val proc: Proof.context -> term -> thm option end
structure Le_Enat_Cancel:
  sig val proc: Proof.context -> term -> thm option end
structure Less_Enat_Cancel:
  sig val proc: Proof.context -> term -> thm option end
instantiation
  enat :: complete_lattice
  Inf_enat == Inf :: enat set \<Rightarrow> enat
  Sup_enat == Sup :: enat set \<Rightarrow> enat
  sup_enat == sup :: enat \<Rightarrow> enat \<Rightarrow> enat
  inf_enat == inf :: enat \<Rightarrow> enat \<Rightarrow> enat
### theory "HOL-Library.Extended_Nat"
### 1.028s elapsed time, 6.028s cpu time, 0.800s GC time
Loading theory "HOL-Library.Extended_Real" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Complex_Transcendental" via "HOL-Analysis.Complex_Analysis_Basics" via "HOL-Analysis.Derivative" via "HOL-Analysis.Uniform_Limit" via "HOL-Analysis.Summation_Tests")
class factorial_semiring = normalization_semidom +
  assumes
    "prime_factorization_exists":
      "\<And>x.
          x \<noteq> (0::'a) \<Longrightarrow>
          \<exists>A.
             (\<forall>x. x \<in># A \<longrightarrow> prime_elem x) \<and>
             prod_mset A = normalize x"
### theory "HOL-Analysis.Cartesian_Space"
### 2.562s elapsed time, 13.360s cpu time, 6.296s GC time
Loading theory "HOL-Analysis.Determinants" (required by "HOL-Analysis.Analysis")
instantiation
  enat :: linorder_topology
  open_enat == open :: enat set \<Rightarrow> bool
### theory "HOL-Analysis.Abstract_Topology_2"
### 2.940s elapsed time, 15.640s cpu time, 6.296s GC time
Loading theory "HOL-Analysis.Connected" (required by "HOL-Analysis.Analysis")
### theory "HOL-Analysis.Convex"
### 2.999s elapsed time, 15.996s cpu time, 6.296s GC time
Loading theory "HOL-Analysis.Elementary_Metric_Spaces" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Abstract_Euclidean_Space" via "HOL-Analysis.Homotopy" via "HOL-Analysis.Path_Connected" via "HOL-Analysis.Starlike" via "HOL-Analysis.Convex_Euclidean_Space" via "HOL-Analysis.Topology_Euclidean_Space" via "HOL-Analysis.Elementary_Normed_Spaces")
### theory "HOL-Analysis.Connected"
### 0.416s elapsed time, 2.480s cpu time, 0.408s GC time
instantiation
  ereal :: uminus
  uminus_ereal == uminus :: ereal \<Rightarrow> ereal
Found termination order: "{}"
instantiation
  ereal :: infinity
  infinity_ereal == infinity :: ereal
### theory "HOL-Analysis.Determinants"
### 0.960s elapsed time, 5.708s cpu time, 0.408s GC time
instantiation
  ereal :: abs
  abs_ereal == abs :: ereal \<Rightarrow> ereal
instantiation
  ereal :: {comm_monoid_add,zero_neq_one}
  one_ereal == one_class.one :: ereal
  zero_ereal == zero_class.zero :: ereal
  plus_ereal == plus :: ereal \<Rightarrow> ereal \<Rightarrow> ereal
instantiation
  ereal :: linorder
  less_eq_ereal == less_eq :: ereal \<Rightarrow> ereal \<Rightarrow> bool
  less_ereal == less :: ereal \<Rightarrow> ereal \<Rightarrow> bool
instantiation
  ereal :: {comm_monoid_mult,sgn}
  sgn_ereal == sgn :: ereal \<Rightarrow> ereal
  times_ereal == times :: ereal \<Rightarrow> ereal \<Rightarrow> ereal
class heine_borel = metric_space +
  assumes
    "bounded_imp_convergent_subsequence":
      "\<And>f.
          bounded (range f) \<Longrightarrow>
          \<exists>l r.
             strict_mono r \<and> (f \<circ> r) \<longlonglongrightarrow> l"
instantiation
  ereal :: minus
  minus_ereal == minus :: ereal \<Rightarrow> ereal \<Rightarrow> ereal
class factorial_semiring_gcd = factorial_semiring + Gcd +
  assumes "gcd_eq_gcd_factorial": "\<And>a b. gcd a b = gcd_factorial a b"
    and "lcm_eq_lcm_factorial": "\<And>a b. lcm a b = lcm_factorial a b"
    and "Gcd_eq_Gcd_factorial": "\<And>A. Gcd A = Gcd_factorial A"
    and "Lcm_eq_Lcm_factorial": "\<And>A. Lcm A = Lcm_factorial A"
instantiation
  ereal :: inverse
  inverse_ereal == inverse :: ereal \<Rightarrow> ereal
  divide_ereal == divide :: ereal \<Rightarrow> ereal \<Rightarrow> ereal
instantiation
  ereal :: lattice
  inf_ereal == inf :: ereal \<Rightarrow> ereal \<Rightarrow> ereal
  sup_ereal == sup :: ereal \<Rightarrow> ereal \<Rightarrow> ereal
instantiation
  ereal :: complete_lattice
  Inf_ereal == Inf :: ereal set \<Rightarrow> ereal
  Sup_ereal == Sup :: ereal set \<Rightarrow> ereal
  bot_ereal == bot :: ereal
  top_ereal == top :: ereal
instantiation
  ereal :: linear_continuum_topology
  open_ereal == open :: ereal set \<Rightarrow> bool
### theory "HOL-Analysis.Elementary_Metric_Spaces"
### 2.583s elapsed time, 15.312s cpu time, 1.448s GC time
Loading theory "HOL-Analysis.Elementary_Normed_Spaces" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Abstract_Euclidean_Space" via "HOL-Analysis.Homotopy" via "HOL-Analysis.Path_Connected" via "HOL-Analysis.Starlike" via "HOL-Analysis.Convex_Euclidean_Space" via "HOL-Analysis.Topology_Euclidean_Space")
### theory "HOL-Library.Extended_Real"
### 5.007s elapsed time, 27.988s cpu time, 6.944s GC time
Loading theory "HOL-Library.Extended_Nonnegative_Real" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Complex_Transcendental" via "HOL-Analysis.Complex_Analysis_Basics" via "HOL-Analysis.Derivative" via "HOL-Analysis.Uniform_Limit" via "HOL-Analysis.Summation_Tests" via "HOL-Analysis.Extended_Real_Limits")
### Rule already declared as introduction (intro)
### (\<And>x. ?f x = ?g x) \<Longrightarrow> ?f = ?g
instantiation
  ennreal :: complete_linorder
  Inf_ennreal == Inf :: ennreal set \<Rightarrow> ennreal
  Sup_ennreal == Sup :: ennreal set \<Rightarrow> ennreal
  bot_ennreal == bot :: ennreal
  sup_ennreal == sup :: ennreal \<Rightarrow> ennreal \<Rightarrow> ennreal
  top_ennreal == top :: ennreal
  inf_ennreal == inf :: ennreal \<Rightarrow> ennreal \<Rightarrow> ennreal
  less_eq_ennreal == less_eq ::
    ennreal \<Rightarrow> ennreal \<Rightarrow> bool
  less_ennreal == less :: ennreal \<Rightarrow> ennreal \<Rightarrow> bool
### Ignoring duplicate rewrite rule:
### f (0::'a) \<equiv> 0::'b
### Ignoring duplicate rewrite rule:
### f (0::'a) \<equiv> 0::'b
instantiation
  ennreal :: infinity
  infinity_ennreal == infinity :: ennreal
instantiation
  ennreal :: {comm_semiring_1,semiring_1_no_zero_divisors}
  zero_ennreal == zero_class.zero :: ennreal
  plus_ennreal == plus ::
    ennreal \<Rightarrow> ennreal \<Rightarrow> ennreal
  one_ennreal == one_class.one :: ennreal
  times_ennreal == times ::
    ennreal \<Rightarrow> ennreal \<Rightarrow> ennreal
instantiation
  ennreal :: minus
  minus_ennreal == minus ::
    ennreal \<Rightarrow> ennreal \<Rightarrow> ennreal
instantiation
  ennreal :: inverse
  inverse_ennreal == inverse :: ennreal \<Rightarrow> ennreal
  divide_ennreal == divide ::
    ennreal \<Rightarrow> ennreal \<Rightarrow> ennreal
### theory "HOL-Analysis.Elementary_Normed_Spaces"
### 1.541s elapsed time, 9.280s cpu time, 0.456s GC time
Loading theory "HOL-Analysis.Topology_Euclidean_Space" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Abstract_Euclidean_Space" via "HOL-Analysis.Homotopy" via "HOL-Analysis.Path_Connected" via "HOL-Analysis.Starlike" via "HOL-Analysis.Convex_Euclidean_Space")
### theory "HOL-Computational_Algebra.Factorial_Ring"
### 8.533s elapsed time, 48.932s cpu time, 8.772s GC time
Loading theory "HOL-Computational_Algebra.Euclidean_Algorithm" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Jordan_Curve" via "HOL-Analysis.Arcwise_Connected" via "HOL-Computational_Algebra.Primes")
structure Cancel_Ennreal_Common:
  sig
    val dest_sum: term -> term list
    val dest_summing: term * term list -> term list
    val find_first: term -> term list -> term list
    val find_first_t: term list -> term -> term list -> term list
    val mk_eq: term * term -> term
    val mk_sum: typ -> term list -> term
    val norm_ss: simpset
    val norm_tac: Proof.context -> tactic
    val simplify_meta_eq: Proof.context -> thm -> thm -> thm
    val trans_tac: Proof.context -> thm option -> tactic
  end
structure Eq_Ennreal_Cancel:
  sig val proc: Proof.context -> term -> thm option end
structure Le_Ennreal_Cancel:
  sig val proc: Proof.context -> term -> thm option end
structure Less_Ennreal_Cancel:
  sig val proc: Proof.context -> term -> thm option end
instantiation
  ennreal :: linear_continuum_topology
  open_ennreal == open :: ennreal set \<Rightarrow> bool
### theory "HOL-Library.Extended_Nonnegative_Real"
### 1.926s elapsed time, 11.592s cpu time, 1.028s GC time
Loading theory "HOL-Analysis.Sigma_Algebra" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Henstock_Kurzweil_Integration" via "HOL-Analysis.Lebesgue_Measure" via "HOL-Analysis.Finite_Product_Measure" via "HOL-Analysis.Binary_Product_Measure" via "HOL-Analysis.Nonnegative_Lebesgue_Integration" via "HOL-Analysis.Measure_Space" via "HOL-Analysis.Measurable")
locale subset_class
  fixes \<Omega> :: "'a set"
    and M :: "'a set set"
  assumes "subset_class \<Omega> M"
locale semiring_of_sets
  fixes \<Omega> :: "'a set"
    and M :: "'a set set"
  assumes "semiring_of_sets \<Omega> M"
locale ring_of_sets
  fixes \<Omega> :: "'a set"
    and M :: "'a set set"
  assumes "ring_of_sets \<Omega> M"
locale algebra
  fixes \<Omega> :: "'a set"
    and M :: "'a set set"
  assumes "algebra \<Omega> M"
locale sigma_algebra
  fixes \<Omega> :: "'a set"
    and M :: "'a set set"
  assumes "sigma_algebra \<Omega> M"
Proofs for inductive predicate(s) "sigma_setsp"
  Proving monotonicity ...
  Proving the introduction rules ...
  Proving the elimination rules ...
  Proving the induction rule ...
  Proving the simplification rules ...
### Ignoring duplicate rewrite rule:
### finite UNIV \<equiv> False
Proofs for inductive predicate(s) "smallest_ccdi_setsp"
  Proving monotonicity ...
  Proving the introduction rules ...
  Proving the elimination rules ...
  Proving the induction rule ...
  Proving the simplification rules ...
### theory "HOL-Analysis.Topology_Euclidean_Space"
### 2.503s elapsed time, 15.080s cpu time, 1.040s GC time
Loading theory "HOL-Analysis.Convex_Euclidean_Space" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Abstract_Euclidean_Space" via "HOL-Analysis.Homotopy" via "HOL-Analysis.Path_Connected" via "HOL-Analysis.Starlike")
Loading theory "HOL-Analysis.Extended_Real_Limits" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Complex_Transcendental" via "HOL-Analysis.Complex_Analysis_Basics" via "HOL-Analysis.Derivative" via "HOL-Analysis.Uniform_Limit" via "HOL-Analysis.Summation_Tests")
Loading theory "HOL-Analysis.Function_Topology" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Abstract_Euclidean_Space" via "HOL-Analysis.Homotopy" via "HOL-Analysis.Path_Connected" via "HOL-Analysis.T1_Spaces" via "HOL-Analysis.Product_Topology")
class euclidean_semiring_gcd = normalization_euclidean_semiring + Gcd +
  assumes "gcd_eucl": "normalization_euclidean_semiring_class.gcd = gcd"
    and "lcm_eucl": "normalization_euclidean_semiring_class.lcm = lcm"
  assumes "Gcd_eucl": "normalization_euclidean_semiring_class.Gcd = Gcd"
    and "Lcm_eucl": "normalization_euclidean_semiring_class.Lcm = Lcm"
locale Dynkin_system
  fixes \<Omega> :: "'a set"
    and M :: "'a set set"
  assumes "Dynkin_system \<Omega> M"
Loading theory "HOL-Analysis.Line_Segment" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Abstract_Euclidean_Space" via "HOL-Analysis.Homotopy" via "HOL-Analysis.Path_Connected" via "HOL-Analysis.Starlike")
instantiation
  fun :: (type, topological_space) topological_space
  open_fun == open :: ('a \<Rightarrow> 'b) set \<Rightarrow> bool
instantiation
  fun :: (countable, metric_space) metric_space
  dist_fun == dist ::
    ('a \<Rightarrow> 'b)
    \<Rightarrow> ('a \<Rightarrow> 'b) \<Rightarrow> real
  uniformity_fun == uniformity ::
    (('a \<Rightarrow> 'b) \<times> ('a \<Rightarrow> 'b)) filter
### Ignoring duplicate rewrite rule:
### interior (ball ?x1 ?e1) \<equiv> ball ?x1 ?e1
### theory "HOL-Analysis.Function_Topology"
### 0.937s elapsed time, 5.628s cpu time, 0.652s GC time
Loading theory "HOL-Analysis.Product_Topology" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Abstract_Euclidean_Space" via "HOL-Analysis.Homotopy" via "HOL-Analysis.Path_Connected" via "HOL-Analysis.T1_Spaces")
### theory "HOL-Analysis.Sigma_Algebra"
### 2.679s elapsed time, 16.128s cpu time, 1.120s GC time
Loading theory "HOL-Analysis.Measurable" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Henstock_Kurzweil_Integration" via "HOL-Analysis.Lebesgue_Measure" via "HOL-Analysis.Finite_Product_Measure" via "HOL-Analysis.Binary_Product_Measure" via "HOL-Analysis.Nonnegative_Lebesgue_Integration" via "HOL-Analysis.Measure_Space")
### theory "HOL-Analysis.Extended_Real_Limits"
### 1.227s elapsed time, 7.376s cpu time, 0.652s GC time
Loading theory "HOL-Analysis.Summation_Tests" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Complex_Transcendental" via "HOL-Analysis.Complex_Analysis_Basics" via "HOL-Analysis.Derivative" via "HOL-Analysis.Uniform_Limit")
### theory "HOL-Analysis.Product_Topology"
### 0.297s elapsed time, 1.796s cpu time, 0.000s GC time
Loading theory "HOL-Analysis.T1_Spaces" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Abstract_Euclidean_Space" via "HOL-Analysis.Homotopy" via "HOL-Analysis.Path_Connected")
### theory "HOL-Analysis.Convex_Euclidean_Space"
### 1.309s elapsed time, 7.876s cpu time, 0.652s GC time
Loading theory "HOL-Analysis.Ordered_Euclidean_Space" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Henstock_Kurzweil_Integration" via "HOL-Analysis.Lebesgue_Measure" via "HOL-Analysis.Finite_Product_Measure" via "HOL-Analysis.Binary_Product_Measure" via "HOL-Analysis.Nonnegative_Lebesgue_Integration" via "HOL-Analysis.Borel_Space")
signature MEASURABLE =
  sig
    val add_del_cong_thm: bool -> thm -> Context.generic -> Context.generic
    val add_local_cong: thm -> Proof.context -> Proof.context
    val add_preprocessor:
       string -> preprocessor -> Context.generic -> Context.generic
    val cong_thm_attr: attribute context_parser
    val del_preprocessor: string -> Context.generic -> Context.generic
    val dest_thm_attr: attribute context_parser
    val get_all: Context.generic -> thm list
    val get_cong: Context.generic -> thm list
    val get_dest: Context.generic -> thm list
    datatype level = Concrete | Generic
    val measurable_tac: Proof.context -> thm list -> tactic
    val measurable_thm_attr: bool * (bool * level) -> attribute
    val prepare_facts: Proof.context -> thm list -> thm list * Proof.context
    type preprocessor = thm -> Proof.context -> thm list * Proof.context
    val simproc: Proof.context -> cterm -> thm option
  end
structure Measurable: MEASURABLE
### theory "HOL-Analysis.T1_Spaces"
### 0.472s elapsed time, 2.824s cpu time, 0.840s GC time
Loading theory "HOL-Analysis.Lindelof_Spaces" (required by "HOL-Analysis.Analysis")
### theory "HOL-Analysis.Line_Segment"
### 1.180s elapsed time, 7.092s cpu time, 0.840s GC time
Loading theory "HOL-Analysis.Starlike" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Abstract_Euclidean_Space" via "HOL-Analysis.Homotopy" via "HOL-Analysis.Path_Connected")
### theory "HOL-Analysis.Lindelof_Spaces"
### 0.101s elapsed time, 0.608s cpu time, 0.000s GC time
Loading theory "HOL-Analysis.Tagged_Division" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Henstock_Kurzweil_Integration")
### theory "HOL-Analysis.Measurable"
### 0.774s elapsed time, 4.644s cpu time, 0.840s GC time
Loading theory "HOL-Analysis.Measure_Space" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Henstock_Kurzweil_Integration" via "HOL-Analysis.Lebesgue_Measure" via "HOL-Analysis.Finite_Product_Measure" via "HOL-Analysis.Binary_Product_Measure" via "HOL-Analysis.Nonnegative_Lebesgue_Integration")
### theory "HOL-Analysis.Summation_Tests"
### 1.051s elapsed time, 6.296s cpu time, 0.840s GC time
Loading theory "HOL-Analysis.Uniform_Limit" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Complex_Transcendental" via "HOL-Analysis.Complex_Analysis_Basics" via "HOL-Analysis.Derivative")
locale operative
  fixes
    f :: "'a \<Rightarrow> 'a \<Rightarrow> 'a"
      (infixl \<open>\<^bold>*\<close> 70)
    and z :: "'a"  (\<open>\<^bold>1\<close>)
    and g :: "'b set \<Rightarrow> 'a"
  assumes "operative (\<^bold>*) \<^bold>1 g"
locale operative_real
  fixes
    f :: "'a \<Rightarrow> 'a \<Rightarrow> 'a"
      (infixl \<open>\<^bold>*\<close> 70)
    and z :: "'a"  (\<open>\<^bold>1\<close>)
    and g :: "real set \<Rightarrow> 'a"
  assumes "operative_real (\<^bold>*) \<^bold>1 g"
class ordered_euclidean_space = Inf + Sup + euclidean_space + abs + inf +
  sup + ord +
  assumes
    "eucl_le":
      "\<And>x y.
          (x \<le> y) =
          (\<forall>i\<in>Basis. x \<bullet> i \<le> y \<bullet> i)"
  assumes
    "eucl_less_le_not_le":
      "\<And>x y. (x < y) = (x \<le> y \<and> \<not> y \<le> x)"
  assumes
    "eucl_inf":
      "\<And>x y.
          inf x y =
          (\<Sum>i\<in>Basis.
             inf (x \<bullet> i) (y \<bullet> i) *\<^sub>R i)"
  assumes
    "eucl_sup":
      "\<And>x y.
          sup x y =
          (\<Sum>i\<in>Basis.
             sup (x \<bullet> i) (y \<bullet> i) *\<^sub>R i)"
  assumes
    "eucl_Inf":
      "\<And>X.
          Inf X =
          (\<Sum>i\<in>Basis. (INF x\<in>X. x \<bullet> i) *\<^sub>R i)"
  assumes
    "eucl_Sup":
      "\<And>X.
          Sup X =
          (\<Sum>i\<in>Basis. (SUP x\<in>X. x \<bullet> i) *\<^sub>R i)"
  assumes
    "eucl_abs":
      "\<And>x.
          \<bar>x\<bar> =
          (\<Sum>i\<in>Basis. \<bar>x \<bullet> i\<bar> *\<^sub>R i)"
locale sigma_finite_measure
  fixes M :: "'a measure"
  assumes "sigma_finite_measure M"
### theory "HOL-Analysis.Tagged_Division"
### 2.660s elapsed time, 13.752s cpu time, 7.508s GC time
### Ignoring duplicate rewrite rule:
### finite UNIV \<equiv> False
### theory "HOL-Analysis.Uniform_Limit"
### 2.358s elapsed time, 11.944s cpu time, 7.508s GC time
Loading theory "HOL-Analysis.Bounded_Continuous_Function" (required by "HOL-Analysis.Analysis")
Loading theory "HOL-Analysis.Bounded_Linear_Function" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Complex_Transcendental" via "HOL-Analysis.Complex_Analysis_Basics" via "HOL-Analysis.Derivative")
instantiation
  bcontfun :: (topological_space, metric_space) metric_space
  dist_bcontfun == dist ::
    'a \<Rightarrow>\<^sub>C 'b
    \<Rightarrow> 'a \<Rightarrow>\<^sub>C 'b \<Rightarrow> real
  uniformity_bcontfun == uniformity ::
    ('a \<Rightarrow>\<^sub>C 'b \<times>
     'a \<Rightarrow>\<^sub>C 'b) filter
  open_bcontfun == open ::
    ('a \<Rightarrow>\<^sub>C 'b) set \<Rightarrow> bool
locale finite_measure
  fixes M :: "'a measure"
  assumes "finite_measure M"
instantiation
  bcontfun :: (topological_space, real_normed_vector) real_vector
  uminus_bcontfun == uminus ::
    'a \<Rightarrow>\<^sub>C 'b \<Rightarrow> 'a \<Rightarrow>\<^sub>C 'b
  zero_bcontfun == zero_class.zero :: 'a \<Rightarrow>\<^sub>C 'b
  minus_bcontfun == minus ::
    'a \<Rightarrow>\<^sub>C 'b
    \<Rightarrow> 'a \<Rightarrow>\<^sub>C 'b
                  \<Rightarrow> 'a \<Rightarrow>\<^sub>C 'b
  plus_bcontfun == plus ::
    'a \<Rightarrow>\<^sub>C 'b
    \<Rightarrow> 'a \<Rightarrow>\<^sub>C 'b
                  \<Rightarrow> 'a \<Rightarrow>\<^sub>C 'b
  scaleR_bcontfun == scaleR ::
    real
    \<Rightarrow> 'a \<Rightarrow>\<^sub>C 'b
                  \<Rightarrow> 'a \<Rightarrow>\<^sub>C 'b
instantiation
  bcontfun :: (topological_space, real_normed_vector) real_normed_vector
  sgn_bcontfun == sgn ::
    'a \<Rightarrow>\<^sub>C 'b \<Rightarrow> 'a \<Rightarrow>\<^sub>C 'b
  norm_bcontfun == norm :: 'a \<Rightarrow>\<^sub>C 'b \<Rightarrow> real
### theory "HOL-Analysis.Bounded_Continuous_Function"
### 0.660s elapsed time, 3.968s cpu time, 0.480s GC time
instantiation
  measure :: (type) order_bot
  bot_measure == bot :: 'a measure
  less_eq_measure == less_eq ::
    'a measure \<Rightarrow> 'a measure \<Rightarrow> bool
  less_measure == less ::
    'a measure \<Rightarrow> 'a measure \<Rightarrow> bool
Proofs for inductive predicate(s) "less_eq_measure"
  Proving monotonicity ...
  Proving the introduction rules ...
  Proving the elimination rules ...
  Proving the induction rule ...
  Proving the simplification rules ...
instantiation
  measure :: (type) semilattice_sup
  sup_measure == sup ::
    'a measure \<Rightarrow> 'a measure \<Rightarrow> 'a measure
instantiation
  measure :: (type) complete_lattice
  Inf_measure == Inf :: 'a measure set \<Rightarrow> 'a measure
  Sup_measure == Sup :: 'a measure set \<Rightarrow> 'a measure
  top_measure == top :: 'a measure
  inf_measure == inf ::
    'a measure \<Rightarrow> 'a measure \<Rightarrow> 'a measure
### theory "HOL-Analysis.Measure_Space"
### 4.145s elapsed time, 22.620s cpu time, 7.988s GC time
Loading theory "HOL-Analysis.Caratheodory" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Henstock_Kurzweil_Integration" via "HOL-Analysis.Lebesgue_Measure")
### theory "HOL-Analysis.Starlike"
### 4.310s elapsed time, 23.604s cpu time, 7.988s GC time
Loading theory "HOL-Analysis.Continuous_Extension" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Retracts")
Loading theory "HOL-Analysis.Path_Connected" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Abstract_Euclidean_Space" via "HOL-Analysis.Homotopy")
instantiation
  blinfun :: (real_normed_vector, real_normed_vector) real_normed_vector
  uminus_blinfun == uminus ::
    'a \<Rightarrow>\<^sub>L 'b \<Rightarrow> 'a \<Rightarrow>\<^sub>L 'b
  zero_blinfun == zero_class.zero :: 'a \<Rightarrow>\<^sub>L 'b
  minus_blinfun == minus ::
    'a \<Rightarrow>\<^sub>L 'b
    \<Rightarrow> 'a \<Rightarrow>\<^sub>L 'b
                  \<Rightarrow> 'a \<Rightarrow>\<^sub>L 'b
  plus_blinfun == plus ::
    'a \<Rightarrow>\<^sub>L 'b
    \<Rightarrow> 'a \<Rightarrow>\<^sub>L 'b
                  \<Rightarrow> 'a \<Rightarrow>\<^sub>L 'b
  sgn_blinfun == sgn ::
    'a \<Rightarrow>\<^sub>L 'b \<Rightarrow> 'a \<Rightarrow>\<^sub>L 'b
  norm_blinfun == norm :: 'a \<Rightarrow>\<^sub>L 'b \<Rightarrow> real
  scaleR_blinfun == scaleR ::
    real
    \<Rightarrow> 'a \<Rightarrow>\<^sub>L 'b
                  \<Rightarrow> 'a \<Rightarrow>\<^sub>L 'b
  dist_blinfun == dist ::
    'a \<Rightarrow>\<^sub>L 'b
    \<Rightarrow> 'a \<Rightarrow>\<^sub>L 'b \<Rightarrow> real
  uniformity_blinfun == uniformity ::
    ('a \<Rightarrow>\<^sub>L 'b \<times>
     'a \<Rightarrow>\<^sub>L 'b) filter
  open_blinfun == open ::
    ('a \<Rightarrow>\<^sub>L 'b) set \<Rightarrow> bool
### theory "HOL-Analysis.Continuous_Extension"
### 0.248s elapsed time, 1.444s cpu time, 0.000s GC time
locale bounded_bilinear
  fixes
    prod :: "'a \<Rightarrow> 'b \<Rightarrow> 'c"
      (infixl \<open>**\<close> 70)
  assumes "bounded_bilinear (**)"
### theory "HOL-Analysis.Caratheodory"
### 0.646s elapsed time, 3.800s cpu time, 0.784s GC time
### theory "HOL-Computational_Algebra.Euclidean_Algorithm"
### 9.416s elapsed time, 54.240s cpu time, 11.304s GC time
Loading theory "HOL-Computational_Algebra.Primes" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Jordan_Curve" via "HOL-Analysis.Arcwise_Connected")
Loading theory "HOL-Computational_Algebra.Formal_Power_Series" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.FPS_Convergence")
instantiation
  prod :: (abs, abs) abs
  abs_prod == abs :: 'a \<times> 'b \<Rightarrow> 'a \<times> 'b
instantiation
  vec :: (ordered_euclidean_space, finite) ordered_euclidean_space
  abs_vec == abs :: ('a, 'b) vec \<Rightarrow> ('a, 'b) vec
  inf_vec == inf ::
    ('a, 'b) vec \<Rightarrow> ('a, 'b) vec \<Rightarrow> ('a, 'b) vec
  sup_vec == sup ::
    ('a, 'b) vec \<Rightarrow> ('a, 'b) vec \<Rightarrow> ('a, 'b) vec
  Inf_vec == Inf :: ('a, 'b) vec set \<Rightarrow> ('a, 'b) vec
  Sup_vec == Sup :: ('a, 'b) vec set \<Rightarrow> ('a, 'b) vec
locale bounded_bilinear
  fixes
    prod :: "'a \<Rightarrow> 'b \<Rightarrow> 'c"
      (infixl \<open>**\<close> 70)
  assumes "bounded_bilinear (**)"
### theory "HOL-Analysis.Ordered_Euclidean_Space"
### 5.793s elapsed time, 32.436s cpu time, 9.612s GC time
### theory "HOL-Computational_Algebra.Primes"
### 0.284s elapsed time, 1.716s cpu time, 0.000s GC time
### theory "HOL-Analysis.Bounded_Linear_Function"
### 2.654s elapsed time, 15.812s cpu time, 1.264s GC time
Loading theory "HOL-Analysis.Derivative" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Complex_Transcendental" via "HOL-Analysis.Complex_Analysis_Basics")
instantiation
  fps :: (zero) zero
  zero_fps == zero_class.zero :: 'a fps
instantiation
  fps :: ({one,zero}) one
  one_fps == one_class.one :: 'a fps
instantiation
  fps :: (plus) plus
  plus_fps == plus :: 'a fps \<Rightarrow> 'a fps \<Rightarrow> 'a fps
instantiation
  fps :: (minus) minus
  minus_fps == minus :: 'a fps \<Rightarrow> 'a fps \<Rightarrow> 'a fps
instantiation
  fps :: (uminus) uminus
  uminus_fps == uminus :: 'a fps \<Rightarrow> 'a fps
instantiation
  fps :: ({comm_monoid_add,times}) times
  times_fps == times :: 'a fps \<Rightarrow> 'a fps \<Rightarrow> 'a fps
### Introduced fixed type variable(s): 'd, 'e, 'f in "f__" or "g__"
### Introduced fixed type variable(s): 'h in "A__"
instantiation
  fps :: (zero) unit_factor
  unit_factor_fps == unit_factor :: 'a fps \<Rightarrow> 'a fps
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<le> (0::?'a1) \<equiv>
### (0::?'a1) \<le> ?a1 \<and> ?b1 \<le> (0::?'a1) \<or>
### ?a1 \<le> (0::?'a1) \<and> (0::?'a1) \<le> ?b1
### Ignoring duplicate rewrite rule:
### p.dim UNIV \<equiv> card Basis_pair
### Ignoring duplicate rewrite rule:
### vs1.dim UNIV \<equiv> card B1
### Ignoring duplicate rewrite rule:
### vs2.dim UNIV \<equiv> card B2
instantiation
  fps :: ({minus,zero}) dist
  dist_fps == dist :: 'a fps \<Rightarrow> 'a fps \<Rightarrow> real
instantiation
  fps :: (group_add) metric_space
  uniformity_fps == uniformity :: ('a fps \<times> 'a fps) filter
  open_fps == open :: 'a fps set \<Rightarrow> bool
### theory "HOL-Analysis.Path_Connected"
### 2.137s elapsed time, 12.812s cpu time, 1.648s GC time
Loading theory "HOL-Analysis.Arcwise_Connected" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Jordan_Curve")
Loading theory "HOL-Analysis.Homotopy" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Abstract_Euclidean_Space")
Loading theory "HOL-Analysis.Locally" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Abstract_Euclidean_Space")
Found termination order: "(\<lambda>p. size (snd (snd p))) <*mlex*> {}"
### theory "HOL-Analysis.Locally"
### 0.213s elapsed time, 1.284s cpu time, 0.000s GC time
Found termination order: "(\<lambda>p. size (snd (snd p))) <*mlex*> {}"
instantiation
  fps :: ({inverse,comm_monoid_add,times,uminus}) inverse
  inverse_fps == inverse :: 'a fps \<Rightarrow> 'a fps
  divide_fps == divide :: 'a fps \<Rightarrow> 'a fps \<Rightarrow> 'a fps
instantiation
  fps :: ({inverse,uminus,comm_semiring_1}) modulo
  modulo_fps == modulo :: 'a fps \<Rightarrow> 'a fps \<Rightarrow> 'a fps
instantiation
  fps :: (field) normalization_semidom
  normalize_fps == normalize :: 'a fps \<Rightarrow> 'a fps
instantiation
  fps :: (field) euclidean_ring_cancel
  euclidean_size_fps == euclidean_size :: 'a fps \<Rightarrow> nat
instantiation
  fps :: (field) euclidean_ring_gcd
  Gcd_fps == Gcd :: 'a fps set \<Rightarrow> 'a fps
  Lcm_fps == Lcm :: 'a fps set \<Rightarrow> 'a fps
  gcd_fps == gcd :: 'a fps \<Rightarrow> 'a fps \<Rightarrow> 'a fps
  lcm_fps == lcm :: 'a fps \<Rightarrow> 'a fps \<Rightarrow> 'a fps
### Introduced fixed type variable(s): 'a in "P__"
Found termination order: "(\<lambda>p. size (fst p)) <*mlex*> {}"
### theory "HOL-Analysis.Derivative"
### 2.536s elapsed time, 15.228s cpu time, 1.660s GC time
Loading theory "HOL-Analysis.Borel_Space" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Henstock_Kurzweil_Integration" via "HOL-Analysis.Lebesgue_Measure" via "HOL-Analysis.Finite_Product_Measure" via "HOL-Analysis.Binary_Product_Measure" via "HOL-Analysis.Nonnegative_Lebesgue_Integration")
Loading theory "HOL-Analysis.Cartesian_Euclidean_Space" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Equivalence_Lebesgue_Henstock_Integration")
Loading theory "HOL-Analysis.Complex_Analysis_Basics" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Complex_Transcendental")
### theory "HOL-Analysis.Arcwise_Connected"
### 1.761s elapsed time, 10.548s cpu time, 0.796s GC time
Loading theory "HOL-Analysis.Lipschitz" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Multivariate_Analysis")
bundle lipschitz_syntax
bundle no_lipschitz_syntax
### theory "HOL-Analysis.Cartesian_Euclidean_Space"
### 0.385s elapsed time, 2.296s cpu time, 0.000s GC time
Loading theory "HOL-Analysis.Cross3" (required by "HOL-Analysis.Analysis")
locale Retracts
  fixes s :: "'a set"
    and h :: "'a \<Rightarrow> 'b"
    and t :: "'b set"
    and k :: "'b \<Rightarrow> 'a"
  assumes "Retracts s h t k"
Found termination order: "(\<lambda>p. size (snd p)) <*mlex*> {}"
Found termination order: "(\<lambda>p. size (snd (snd p))) <*mlex*> {}"
### theory "HOL-Analysis.Lipschitz"
### 0.705s elapsed time, 4.212s cpu time, 0.864s GC time
Loading theory "HOL-Analysis.Polytope" (required by "HOL-Analysis.Analysis")
### theory "HOL-Analysis.Homotopy"
### 2.772s elapsed time, 16.600s cpu time, 1.660s GC time
Loading theory "HOL-Analysis.Homeomorphism" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Retracts" via "HOL-Analysis.Brouwer_Fixpoint")
### theory "HOL-Analysis.Complex_Analysis_Basics"
### 1.483s elapsed time, 8.876s cpu time, 0.864s GC time
Loading theory "HOL-Analysis.Complex_Transcendental" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem")
bundle fps_notation
### theory "HOL-Computational_Algebra.Formal_Power_Series"
### 4.615s elapsed time, 27.700s cpu time, 2.524s GC time
Loading theory "HOL-Analysis.Abstract_Euclidean_Space" (required by "HOL-Analysis.Analysis")
bundle cross3_syntax
### theory "HOL-Analysis.Homeomorphism"
### 0.711s elapsed time, 4.264s cpu time, 0.948s GC time
Loading theory "HOL-Analysis.Brouwer_Fixpoint" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Retracts")
### theory "HOL-Analysis.Abstract_Euclidean_Space"
### 0.494s elapsed time, 2.960s cpu time, 0.948s GC time
Loading theory "HOL-Analysis.Weierstrass_Theorems" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem")
bundle no_cross3_syntax
instantiation
  complex :: ln
  ln_complex == ln :: complex \<Rightarrow> complex
### theory "HOL-Analysis.Polytope"
### 1.711s elapsed time, 10.288s cpu time, 0.948s GC time
### theory "HOL-Analysis.Borel_Space"
### 2.798s elapsed time, 16.780s cpu time, 1.812s GC time
Loading theory "HOL-Analysis.Nonnegative_Lebesgue_Integration" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Henstock_Kurzweil_Integration" via "HOL-Analysis.Lebesgue_Measure" via "HOL-Analysis.Finite_Product_Measure" via "HOL-Analysis.Binary_Product_Measure")
Loading theory "HOL-Analysis.Regularity" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Henstock_Kurzweil_Integration" via "HOL-Analysis.Lebesgue_Measure")
locale function_ring_on
  fixes R :: "('a \<Rightarrow> real) set"
    and S :: "'a set"
  assumes "function_ring_on R S"
Proofs for inductive predicate(s) "real_polynomial_function"
locale kuhn_simplex
  fixes p :: "nat"
    and n :: "nat"
    and base :: "nat \<Rightarrow> nat"
    and upd :: "nat \<Rightarrow> nat"
    and s :: "(nat \<Rightarrow> nat) set"
  assumes "kuhn_simplex p n base upd s"
  Proving monotonicity ...
  Proving the introduction rules ...
  Proving the elimination rules ...
  Proving the induction rule ...
  Proving the simplification rules ...
locale kuhn_simplex_pair
  fixes p :: "nat"
    and n :: "nat"
    and b_s :: "nat \<Rightarrow> nat"
    and u_s :: "nat \<Rightarrow> nat"
    and s :: "(nat \<Rightarrow> nat) set"
    and b_t :: "nat \<Rightarrow> nat"
    and u_t :: "nat \<Rightarrow> nat"
    and t :: "(nat \<Rightarrow> nat) set"
  assumes "kuhn_simplex_pair p n b_s u_s s b_t u_t t"
Proofs for inductive predicate(s) "ksimplex"
  Proving monotonicity ...
  Proving the introduction rules ...
  Proving the elimination rules ...
  Proving the induction rule ...
  Proving the simplification rules ...
### theory "HOL-Analysis.Weierstrass_Theorems"
### 3.192s elapsed time, 16.636s cpu time, 10.088s GC time
### theory "HOL-Analysis.Regularity"
### 2.869s elapsed time, 14.692s cpu time, 10.088s GC time
### theory "HOL-Analysis.Brouwer_Fixpoint"
### 3.552s elapsed time, 18.812s cpu time, 10.088s GC time
Loading theory "HOL-Analysis.Fashoda_Theorem" (required by "HOL-Analysis.Analysis")
Loading theory "HOL-Analysis.Retracts" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem")
### theory "HOL-Analysis.Complex_Transcendental"
### 4.341s elapsed time, 23.552s cpu time, 11.036s GC time
Loading theory "HOL-Analysis.Generalised_Binomial_Theorem" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.FPS_Convergence")
Loading theory "HOL-Analysis.Infinite_Products" (required by "HOL-Analysis.Analysis")
### theory "HOL-Analysis.Cross3"
### 5.603s elapsed time, 31.112s cpu time, 11.900s GC time
Loading theory "HOL-Analysis.Multivariate_Analysis" (required by "HOL-Analysis.Analysis")
### theory "HOL-Analysis.Generalised_Binomial_Theorem"
### 0.081s elapsed time, 0.488s cpu time, 0.000s GC time
### theory "HOL-Analysis.Fashoda_Theorem"
### 0.638s elapsed time, 3.908s cpu time, 0.924s GC time
### theory "HOL-Analysis.Infinite_Products"
### 0.721s elapsed time, 4.408s cpu time, 0.924s GC time
### theory "HOL-Analysis.Nonnegative_Lebesgue_Integration"
### 4.173s elapsed time, 22.620s cpu time, 11.012s GC time
Loading theory "HOL-Analysis.Binary_Product_Measure" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Henstock_Kurzweil_Integration" via "HOL-Analysis.Lebesgue_Measure" via "HOL-Analysis.Finite_Product_Measure")
locale pair_sigma_finite
  fixes M1 :: "'a measure"
    and M2 :: "'b measure"
  assumes "pair_sigma_finite M1 M2"
### theory "HOL-Analysis.Retracts"
### 1.688s elapsed time, 10.152s cpu time, 0.924s GC time
### theory "HOL-Analysis.Multivariate_Analysis"
### 1.791s elapsed time, 10.556s cpu time, 1.864s GC time
### theory "HOL-Analysis.Binary_Product_Measure"
### 0.905s elapsed time, 5.024s cpu time, 0.940s GC time
Loading theory "HOL-Analysis.Embed_Measure" (required by "HOL-Analysis.Analysis")
Loading theory "HOL-Analysis.Finite_Product_Measure" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Henstock_Kurzweil_Integration" via "HOL-Analysis.Lebesgue_Measure")
### theory "HOL-Analysis.Embed_Measure"
### 0.208s elapsed time, 1.216s cpu time, 0.000s GC time
locale product_sigma_finite
  fixes M :: "'i \<Rightarrow> 'a measure"
  assumes "product_sigma_finite M"
locale finite_product_sigma_finite
  fixes M :: "'i \<Rightarrow> 'a measure"
    and I :: "'i set"
  assumes "finite_product_sigma_finite M I"
### theory "HOL-Analysis.Finite_Product_Measure"
### 1.176s elapsed time, 7.092s cpu time, 0.812s GC time
Loading theory "HOL-Analysis.Bochner_Integration" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Henstock_Kurzweil_Integration" via "HOL-Analysis.Lebesgue_Measure" via "HOL-Analysis.Complete_Measure")
Proofs for inductive predicate(s) "simple_bochner_integrable"
  Proving monotonicity ...
  Proving the introduction rules ...
  Proving the elimination rules ...
  Proving the induction rule ...
  Proving the simplification rules ...
Proofs for inductive predicate(s) "has_bochner_integral"
  Proving monotonicity ...
  Proving the introduction rules ...
  Proving the elimination rules ...
  Proving the induction rule ...
  Proving the simplification rules ...
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
Proofs for inductive predicate(s) "integrable"
  Proving monotonicity ...
  Proving the introduction rules ...
  Proving the elimination rules ...
  Proving the induction rule ...
  Proving the simplification rules ...
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### theory "HOL-Analysis.Bochner_Integration"
### 1.780s elapsed time, 10.640s cpu time, 0.840s GC time
Loading theory "HOL-Analysis.Complete_Measure" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Henstock_Kurzweil_Integration" via "HOL-Analysis.Lebesgue_Measure")
Loading theory "HOL-Analysis.Radon_Nikodym" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Equivalence_Lebesgue_Henstock_Integration" via "HOL-Analysis.Set_Integral")
locale complete_measure
  fixes M :: "'a measure"
  assumes "complete_measure M"
locale semifinite_measure
  fixes M :: "'a measure"
  assumes "semifinite_measure M"
locale locally_determined_measure
  fixes M :: "'a measure"
  assumes "locally_determined_measure M"
locale cld_measure
  fixes M :: "'a measure"
  assumes "cld_measure M"
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### theory "HOL-Analysis.Radon_Nikodym"
### 0.314s elapsed time, 1.892s cpu time, 0.000s GC time
Loading theory "HOL-Analysis.Set_Integral" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Equivalence_Lebesgue_Henstock_Integration")
### theory "HOL-Analysis.Complete_Measure"
### 0.722s elapsed time, 4.412s cpu time, 0.820s GC time
Loading theory "HOL-Analysis.Lebesgue_Measure" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem" via "HOL-Analysis.Henstock_Kurzweil_Integration")
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### theory "HOL-Analysis.Set_Integral"
### 0.721s elapsed time, 4.428s cpu time, 0.820s GC time
Loading theory "HOL-Analysis.Infinite_Set_Sum" (required by "HOL-Analysis.Analysis")
### theory "HOL-Analysis.Infinite_Set_Sum"
### 0.497s elapsed time, 2.988s cpu time, 0.000s GC time
### Ignoring duplicate rewrite rule:
### ?X1 derived_set_of (topspace ?X1 \<inter> ?S1) \<equiv>
### ?X1 derived_set_of ?S1
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
Proofs for inductive predicate(s) "fsigma"
  Proving monotonicity ...
  Proving the introduction rules ...
  Proving the elimination rules ...
  Proving the induction rule ...
  Proving the simplification rules ...
Proofs for inductive predicate(s) "gdelta"
  Proving monotonicity ...
  Proving the introduction rules ...
  Proving the elimination rules ...
  Proving the induction rule ...
  Proving the simplification rules ...
### theory "HOL-Analysis.Lebesgue_Measure"
### 1.905s elapsed time, 10.720s cpu time, 0.856s GC time
Loading theory "HOL-Analysis.Henstock_Kurzweil_Integration" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings" via "HOL-Analysis.Cauchy_Integral_Theorem")
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; Ball ?S open\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Introduced fixed type variable(s): 'b in "Q__" or "f__"
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### theory "HOL-Analysis.Henstock_Kurzweil_Integration"
### 3.345s elapsed time, 17.532s cpu time, 1.612s GC time
Loading theory "HOL-Analysis.Cauchy_Integral_Theorem" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Conformal_Mappings")
Loading theory "HOL-Analysis.Equivalence_Lebesgue_Henstock_Integration" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function")
Loading theory "HOL-Analysis.Integral_Test" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function" via "HOL-Analysis.Harmonic_Numbers")
locale antimono_fun_sum_integral_diff
  fixes f :: "real \<Rightarrow> real"
  assumes "antimono_fun_sum_integral_diff f"
### theory "HOL-Analysis.Integral_Test"
### 0.279s elapsed time, 1.608s cpu time, 1.008s GC time
Loading theory "HOL-Analysis.Harmonic_Numbers" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function")
### Introduced fixed type variable(s): 'd, 'e, 'f in "f__" or "g__"
### Introduced fixed type variable(s): 'd, 'e in "X__" or "f__" or "g__"
### Introduced fixed type variable(s): 'd, 'e in "f__"
### Introduced fixed type variable(s): 'd in "X__"
### Introduced fixed type variable(s): 'd, 'e, 'f in "R__" or "S__"
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Introduced fixed type variable(s): 'd, 'e in "R__"
### Ignoring duplicate rewrite rule:
### mset (map ?f1 ?xs1) \<equiv> image_mset ?f1 (mset ?xs1)
### Ignoring duplicate rewrite rule:
### mset (map ?f1 ?xs1) \<equiv> image_mset ?f1 (mset ?xs1)
### Introduced fixed type variable(s): 'd in "z__"
### Introduced fixed type variable(s): 'd in "P__"
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Metis: Unused theorems: "Lattices.semilattice_inf_class.inf.assoc", "Lattices.semilattice_inf_class.inf.orderE"
### Metis: Unused theorems: "Lattices.semilattice_inf_class.inf.assoc", "Lattices.semilattice_inf_class.inf.orderE"
### theory "HOL-Analysis.Harmonic_Numbers"
### 0.721s elapsed time, 4.232s cpu time, 0.000s GC time
### Metis: Unused theorems: "Fun.eq_id_iff"
### Metis: Unused theorems: "Fun.eq_id_iff"
locale Chain
  fixes x0 :: "'a"
    and At :: "'a \<Rightarrow> nat \<Rightarrow> bool"
    and Follows :: "'a \<Rightarrow> 'a \<Rightarrow> bool"
  assumes "Chain x0 At Follows"
consts
  f :: "nat \<Rightarrow> 'a"
### theory "HOL-Analysis.Equivalence_Lebesgue_Henstock_Integration"
### 2.851s elapsed time, 15.976s cpu time, 1.728s GC time
Loading theory "HOL-Analysis.Further_Topology" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Jordan_Curve")
Loading theory "HOL-Analysis.Improper_Integral" (required by "HOL-Analysis.Analysis")
Loading theory "HOL-Analysis.Interval_Integral" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Lebesgue_Integral_Substitution")
### theory "HOL-Analysis.Improper_Integral"
### 0.442s elapsed time, 2.624s cpu time, 0.000s GC time
Loading theory "HOL-Analysis.Equivalence_Measurable_On_Borel" (required by "HOL-Analysis.Analysis")
### theory "HOL-Analysis.Interval_Integral"
### 0.589s elapsed time, 3.508s cpu time, 0.000s GC time
Loading theory "HOL-Analysis.Lebesgue_Integral_Substitution" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume")
### theory "HOL-Analysis.Lebesgue_Integral_Substitution"
### 0.255s elapsed time, 1.556s cpu time, 0.908s GC time
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### theory "HOL-Analysis.Equivalence_Measurable_On_Borel"
### 0.863s elapsed time, 5.212s cpu time, 0.908s GC time
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### theory "HOL-Analysis.Cauchy_Integral_Theorem"
### 4.596s elapsed time, 26.160s cpu time, 2.636s GC time
Loading theory "HOL-Analysis.Conformal_Mappings" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume" via "HOL-Analysis.Gamma_Function")
### theory "HOL-Analysis.Further_Topology"
### 3.176s elapsed time, 18.356s cpu time, 1.748s GC time
Loading theory "HOL-Analysis.Jordan_Curve" (required by "HOL-Analysis.Analysis")
### theory "HOL-Analysis.Conformal_Mappings"
### 1.716s elapsed time, 9.616s cpu time, 0.840s GC time
Loading theory "HOL-Analysis.FPS_Convergence" (required by "HOL-Analysis.Analysis")
Loading theory "HOL-Analysis.Great_Picard" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Winding_Numbers" via "HOL-Analysis.Riemann_Mapping")
Loading theory "HOL-Analysis.Gamma_Function" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Ball_Volume")
### theory "HOL-Analysis.Jordan_Curve"
### 1.042s elapsed time, 6.204s cpu time, 0.900s GC time
### theory "HOL-Analysis.Great_Picard"
### 0.988s elapsed time, 6.016s cpu time, 0.900s GC time
Loading theory "HOL-Analysis.Riemann_Mapping" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Winding_Numbers")
locale SC_Chain
  fixes S :: "complex set"
  assumes "SC_Chain S"
locale SC_Chain
  fixes S :: "complex set"
  assumes "SC_Chain S"
locale SC_Chain
  fixes S :: "complex set"
  assumes "SC_Chain S"
### theory "HOL-Analysis.Riemann_Mapping"
### 0.342s elapsed time, 2.044s cpu time, 0.000s GC time
Loading theory "HOL-Analysis.Winding_Numbers" (required by "HOL-Analysis.Analysis")
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### theory "HOL-Analysis.FPS_Convergence"
### 2.051s elapsed time, 12.468s cpu time, 1.792s GC time
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### theory "HOL-Analysis.Winding_Numbers"
### 1.006s elapsed time, 6.116s cpu time, 0.892s GC time
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
class Gamma = complete_space + real_normed_field +
  fixes rGamma :: "'a \<Rightarrow> 'a"
  assumes
    "rGamma_eq_zero_iff_aux":
      "\<And>z. (rGamma z = (0::'a)) = (\<exists>n. z = - of_nat n)"
  assumes
    "differentiable_rGamma_aux1":
      "\<And>z.
          (\<And>n. z \<noteq> - of_nat n) \<Longrightarrow>
          let d = (THE d.
                      (\<lambda>n.
                          \<Sum>k<n.
                             inverse (of_nat (Suc k)) -
                             inverse (z + of_nat k))
                      \<longlonglongrightarrow> d) -
                  euler_mascheroni *\<^sub>R (1::'a)
          in ((\<lambda>y.
                  (rGamma y - rGamma z + rGamma z * d * (y - z)) /\<^sub>R
                  norm (y - z)) \<longlongrightarrow>
              (0::'a))
              (at z)"
  assumes
    "differentiable_rGamma_aux2":
      "\<And>n.
          let z = - of_nat n
          in ((\<lambda>y.
                  (rGamma y - rGamma z -
                   (- (1::'a)) ^ n * prod of_nat {1..n} * (y - z)) /\<^sub>R
                  norm (y - z)) \<longlongrightarrow>
              (0::'a))
              (at z)"
  assumes
    "rGamma_series_aux":
      "\<And>z.
          (\<And>n. z \<noteq> - of_nat n) \<Longrightarrow>
          let fact' = \<lambda>n. prod of_nat {1..n};
              exp =
                \<lambda>x.
                   THE e.
                      (\<lambda>n. \<Sum>k<n. x ^ k /\<^sub>R fact k)
                      \<longlonglongrightarrow> e;
              pochhammer' = \<lambda>a n. \<Prod>n = 0..n. a + of_nat n
          in (\<lambda>n.
                 pochhammer' z n /
                 (fact' n * exp (z * ln (real n) *\<^sub>R (1::'a))))
             \<longlonglongrightarrow> rGamma z"
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
instantiation
  complex :: Gamma
  rGamma_complex == rGamma :: complex \<Rightarrow> complex
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
instantiation
  real :: Gamma
  rGamma_real == rGamma :: real \<Rightarrow> real
### theory "HOL-Analysis.Gamma_Function"
### 4.227s elapsed time, 25.424s cpu time, 2.524s GC time
Loading theory "HOL-Analysis.Ball_Volume" (required by "HOL-Analysis.Analysis")
### Ignoring duplicate rewrite rule:
### open {} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed UNIV \<equiv> True
### Ignoring duplicate rewrite rule:
### closed ?S1 \<Longrightarrow> closed (insert ?a1 ?S1) \<equiv> True
### Ignoring duplicate rewrite rule:
### open {?a1<..} \<equiv> True
### Ignoring duplicate rewrite rule:
### open {..<?a1} \<equiv> True
### Ignoring duplicate rewrite rule:
### open {?a1<..<?b1} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {..?a1} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {?a1..} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {?a1..?b1} \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 id \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous bot ?f1 \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous (at ?x1 within ?S1) (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous (at ?x1 within ?S1) id \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous ?F1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; isCont ?g1 ?a1; ?g1 ?a1 \<noteq> (0::?'b1)\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. ?f1 x / ?g1 x) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; isCont ?g1 ?a1; 0 < ?f1 ?a1; ?f1 ?a1 \<noteq> 1;
###  0 < ?g1 ?a1\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. log (?f1 x) (?g1 x)) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; isCont ?g1 ?a1; ?f1 ?a1 \<noteq> 0\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. ?f1 x powr ?g1 x) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; cos (?f1 ?a1) \<noteq> (0::?'a1)\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. tan (?f1 x)) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; sin (?f1 ?a1) \<noteq> (0::?'a1)\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. cot (?f1 x)) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous ?F1 ?g1 \<Longrightarrow>
### continuous ?F1 (\<lambda>x. cnj (?g1 x)) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 ?g1 \<Longrightarrow>
### continuous_on ?s1 (\<lambda>x. cnj (?g1 x)) \<equiv> True
### theory "HOL-Analysis.Ball_Volume"
### 0.708s elapsed time, 4.324s cpu time, 0.728s GC time
Loading theory "HOL-Analysis.Vitali_Covering_Theorem" (required by "HOL-Analysis.Analysis" via "HOL-Analysis.Change_Of_Vars")
### theory "HOL-Analysis.Vitali_Covering_Theorem"
### 0.633s elapsed time, 3.756s cpu time, 0.000s GC time
Loading theory "HOL-Analysis.Change_Of_Vars" (required by "HOL-Analysis.Analysis")
### theory "HOL-Analysis.Change_Of_Vars"
### 1.243s elapsed time, 7.412s cpu time, 0.792s GC time
Loading theory "HOL-Analysis.Simplex_Content" (required by "HOL-Analysis.Analysis")
### theory "HOL-Analysis.Simplex_Content"
### 0.099s elapsed time, 0.568s cpu time, 0.000s GC time
Loading theory "HOL-Analysis.Analysis"
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### theory "HOL-Analysis.Analysis"
### 5.333s elapsed time, 30.508s cpu time, 2.920s GC time
### Ignoring duplicate rewrite rule:
### inverse_permutation_of_list [] ?y \<equiv> ?y
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Ignoring duplicate rewrite rule:
### convex (convex hull ?s1) \<equiv> True
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Metis: Unused theorems: "Cartesian_Space.matrix_vector_mul_1", "Cartesian_Space.matrix_vector_mul_3"
### Metis: Unused theorems: "Permutations.permutation_swap_id"
### Metis: Unused theorems: "Finite_Set.finite_class.finite_code"
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Rule already declared as elimination (elim)
### \<lbrakk>?b dvd ?a; \<And>k. ?a = ?b * k \<Longrightarrow> ?P\<rbrakk>
### \<Longrightarrow> ?P
### Ignoring duplicate rewrite rule:
### ?y1 \<in> ball ?x1 ?e1 \<equiv> dist ?x1 ?y1 < ?e1
### Ignoring duplicate rewrite rule:
### ?y1 \<in> cball ?x1 ?e1 \<equiv> dist ?x1 ?y1 \<le> ?e1
### Ignoring duplicate rewrite rule:
### ?y1 \<in> ball ?x1 ?e1 \<equiv> dist ?x1 ?y1 < ?e1
### Ignoring duplicate rewrite rule:
### ?y1 \<in> cball ?x1 ?e1 \<equiv> dist ?x1 ?y1 \<le> ?e1
### Ignoring duplicate rewrite rule:
### ?y1 \<in> ball ?x1 ?e1 \<equiv> dist ?x1 ?y1 < ?e1
### Ignoring duplicate rewrite rule:
### ?y1 \<in> cball ?x1 ?e1 \<equiv> dist ?x1 ?y1 \<le> ?e1
### Ignoring duplicate rewrite rule:
### ?y1 \<in> ball ?x1 ?e1 \<equiv> dist ?x1 ?y1 < ?e1
### Ignoring duplicate rewrite rule:
### ?y1 \<in> cball ?x1 ?e1 \<equiv> dist ?x1 ?y1 \<le> ?e1
### Ignoring duplicate rewrite rule:
### ?y1 \<in> ball ?x1 ?e1 \<equiv> dist ?x1 ?y1 < ?e1
### Ignoring duplicate rewrite rule:
### 0 < dist ?x1 ?y1 \<equiv> ?x1 \<noteq> ?y1
### Ignoring duplicate introduction (intro)
### ((\<lambda>x. x) \<longlongrightarrow> ?a) (at ?a within ?s)
### Ignoring duplicate introduction (intro)
### ((\<lambda>x. ?k) \<longlongrightarrow> ?k) ?F
### Rule already declared as introduction (intro)
### countable ?A \<Longrightarrow> countable (?f ` ?A)
### Rule already declared as introduction (intro)
### \<lbrakk>countable ?I;
###  \<And>i. i \<in> ?I \<Longrightarrow> countable (?A i)\<rbrakk>
### \<Longrightarrow> countable (Sigma ?I ?A)
### Rule already declared as introduction (intro)
### \<lbrakk>countable ?I;
###  \<And>i. i \<in> ?I \<Longrightarrow> countable (?A i)\<rbrakk>
### \<Longrightarrow> countable (\<Union> (?A ` ?I))
### Rule already declared as introduction (intro)
### ?P ?x \<Longrightarrow> \<exists>x. ?P x
### Ignoring duplicate rewrite rule:
### of_nat (Suc ?m1) \<equiv> (1::?'a1) + of_nat ?m1
### Ignoring duplicate rewrite rule:
### open {} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed UNIV \<equiv> True
### Ignoring duplicate rewrite rule:
### closed ?S1 \<Longrightarrow> closed (insert ?a1 ?S1) \<equiv> True
### Ignoring duplicate rewrite rule:
### open {?a1<..} \<equiv> True
### Ignoring duplicate rewrite rule:
### open {..<?a1} \<equiv> True
### Ignoring duplicate rewrite rule:
### open {?a1<..<?b1} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {..?a1} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {?a1..} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {?a1..?b1} \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 id \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous bot ?f1 \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous (at ?x1 within ?S1) (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous (at ?x1 within ?S1) id \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous ?F1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; isCont ?g1 ?a1; ?g1 ?a1 \<noteq> (0::?'b1)\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. ?f1 x / ?g1 x) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; isCont ?g1 ?a1; 0 < ?f1 ?a1; ?f1 ?a1 \<noteq> 1;
###  0 < ?g1 ?a1\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. log (?f1 x) (?g1 x)) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; isCont ?g1 ?a1; ?f1 ?a1 \<noteq> 0\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. ?f1 x powr ?g1 x) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; cos (?f1 ?a1) \<noteq> (0::?'a1)\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. tan (?f1 x)) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; sin (?f1 ?a1) \<noteq> (0::?'a1)\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. cot (?f1 x)) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous ?F1 ?g1 \<Longrightarrow>
### continuous ?F1 (\<lambda>x. cnj (?g1 x)) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 ?g1 \<Longrightarrow>
### continuous_on ?s1 (\<lambda>x. cnj (?g1 x)) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_map ?X1 ?X1 id \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_map ?X1 ?X1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### closure ?S1 = {} \<equiv> ?S1 = {}
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
"True"
  :: "bool"
"True"
  :: "bool"
"- \<infinity>"
  :: "ereal"
"\<infinity>"
  :: "ereal"
### Ignoring duplicate introduction (intro)
### ((\<lambda>x. x) \<longlongrightarrow> ?a) (at ?a within ?s)
### Ignoring duplicate introduction (intro)
### ((\<lambda>x. x) \<longlongrightarrow> ?a) (at ?a within ?s)
### Ignoring duplicate introduction (intro)
### ((\<lambda>x. ?k) \<longlongrightarrow> ?k) ?F
### Ignoring duplicate introduction (intro)
### ((\<lambda>x. ?k) \<longlongrightarrow> ?k) ?F
"ereal (13 / 4)"
  :: "ereal"
### Ignoring duplicate rewrite rule:
### sup ?x1 (- ?x1) \<equiv> top
### Ignoring duplicate rewrite rule:
### open {} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed UNIV \<equiv> True
### Ignoring duplicate rewrite rule:
### closed ?S1 \<Longrightarrow> closed (insert ?a1 ?S1) \<equiv> True
### Ignoring duplicate rewrite rule:
### open {?a1<..} \<equiv> True
### Ignoring duplicate rewrite rule:
### open {..<?a1} \<equiv> True
### Ignoring duplicate rewrite rule:
### open {?a1<..<?b1} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {..?a1} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {?a1..} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {?a1..?b1} \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 id \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous bot ?f1 \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous (at ?x1 within ?S1) (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous (at ?x1 within ?S1) id \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous ?F1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; isCont ?g1 ?a1; ?g1 ?a1 \<noteq> (0::?'b1)\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. ?f1 x / ?g1 x) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; isCont ?g1 ?a1; 0 < ?f1 ?a1; ?f1 ?a1 \<noteq> 1;
###  0 < ?g1 ?a1\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. log (?f1 x) (?g1 x)) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; isCont ?g1 ?a1; ?f1 ?a1 \<noteq> 0\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. ?f1 x powr ?g1 x) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; cos (?f1 ?a1) \<noteq> (0::?'a1)\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. tan (?f1 x)) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; sin (?f1 ?a1) \<noteq> (0::?'a1)\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. cot (?f1 x)) ?a1 \<equiv> True
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Ignoring duplicate rewrite rule:
### continuous ?F1 ?g1 \<Longrightarrow>
### continuous ?F1 (\<lambda>x. cnj (?g1 x)) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 ?g1 \<Longrightarrow>
### continuous_on ?s1 (\<lambda>x. cnj (?g1 x)) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_map ?X1 ?X1 id \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_map ?X1 ?X1 (\<lambda>x. x) \<equiv> True
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### (\<And>x y. ?A x y \<Longrightarrow> ?B (?f x) (?g y)) \<Longrightarrow>
### rel_fun ?A ?B ?f ?g
### Ignoring duplicate rewrite rule:
### dim UNIV \<equiv> DIM(?'a1)
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Rule already declared as introduction (intro)
### (\<And>x y. ?A x y \<Longrightarrow> ?B (?f x) (?g y)) \<Longrightarrow>
### rel_fun ?A ?B ?f ?g
### Ignoring duplicate rewrite rule:
### 0 < DIM(?'a1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### cbox ?a1 ?a1 \<equiv> {?a1}
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### 0 < DIM(?'a1) \<equiv> True
### Rule already declared as introduction (intro)
### range ?A \<subseteq> M \<Longrightarrow> \<Union> (range ?A) \<in> M
### Rule already declared as introduction (intro)
### (\<And>x. ?f x = ?g x) \<Longrightarrow> ?f = ?g
### Ignoring duplicate rewrite rule:
### (\<And>i.
###     i \<in> Basis \<Longrightarrow>
###     ?a1 \<bullet> i \<le> ?b1 \<bullet> i) \<Longrightarrow>
### clamp ?a1 ?b1 ?x1 \<in> cbox ?a1 ?b1 \<equiv> True
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 < (0::?'a1) \<equiv>
### (0::?'a1) < ?a1 \<and> ?b1 < (0::?'a1) \<or>
### ?a1 < (0::?'a1) \<and> (0::?'a1) < ?b1
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### subspace (span ?S1) \<equiv> True
### Ignoring duplicate introduction (intro)
### ?a \<in> ?A \<Longrightarrow> ?a \<in> sigma_sets ?sp ?A
### Rule already declared as introduction (intro)
### \<lbrakk>?a \<in> generated_ring; ?b \<in> generated_ring;
###  ?a \<inter> ?b = {}\<rbrakk>
### \<Longrightarrow> ?a \<union> ?b \<in> generated_ring
### Ignoring duplicate rewrite rule:
### topspace (topology_generated_by ?S1) \<equiv> \<Union> ?S1
### Ignoring duplicate rewrite rule:
### topspace (product_topology ?T1 ?I1) \<equiv>
### \<Pi>\<^sub>E i\<in>?I1. topspace (?T1 i)
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Ignoring duplicate rewrite rule:
### 0 < dist ?x1 ?y1 \<equiv> ?x1 \<noteq> ?y1
### Ignoring duplicate rewrite rule:
### 0 < dist ?x1 ?y1 \<equiv> ?x1 \<noteq> ?y1
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### interior {?a1..} \<equiv> {?a1<..}
### Ignoring duplicate rewrite rule:
### interior {..?a1} \<equiv> {..<?a1}
### Ignoring duplicate rewrite rule:
### interior {..?a1} \<equiv> {..<?a1}
### Ignoring duplicate rewrite rule:
### interior (cbox ?a1 ?b1) \<equiv> box ?a1 ?b1
### Rule already declared as introduction (intro)
### \<lbrakk>?a \<in> sets ?M; ?b \<in> sets ?M\<rbrakk>
### \<Longrightarrow> ?a \<inter> ?b \<in> sets ?M
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Rule already declared as introduction (intro)
### ((\<lambda>x. x) \<longlongrightarrow> ?a) (at ?a within ?s)
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### quotient_map (prod_topology ?X1 ?Y1) ?X1 fst \<equiv>
### topspace ?Y1 = {} \<longrightarrow> topspace ?X1 = {}
### Ignoring duplicate rewrite rule:
### quotient_map (prod_topology ?X1 ?Y1) ?Y1 snd \<equiv>
### topspace ?X1 = {} \<longrightarrow> topspace ?Y1 = {}
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### 0 < DIM(?'a1) \<equiv> True
### Introduced fixed type variable(s): 'b in "Sa__" or "T__" or "xa__"
### Introduced fixed type variable(s): 'c, 'd in "x__" or "y__"
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Rule already declared as introduction (intro)
### ?x \<in> UNIV
### Rule already declared as introduction (intro)
### ?x \<in> UNIV
Failure node
Enter MATCH
Failure node
Enter MATCH
\<lambda>a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay.
   :001
    (:000
      (?T55 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax
        ay)) \<equiv>\<^sup>?
?T55
 (:000
   (\<lambda>a.
       :001
        (:000
          (\<lambda>b.
              :001
               (:000
                 (\<lambda>c.
                     :001
                      (:000
                        (\<lambda>d.
                            :001
                             (:000
                               (\<lambda>e.
                                   :001
                                    (:000
(\<lambda>f.
    :001
     (:000
       (\<lambda>g.
           :001
            (:000
              (\<lambda>h.
                  :001
                   (:000
                     (\<lambda>i.
                         :001
                          (:000
                            (\<lambda>j.
                                :001
                                 (:000
                                   (\<lambda>k.
 :001
  (:000
    (\<lambda>l.
        :001
         (:000
           (\<lambda>m.
               :001
                (:000
                  (\<lambda>n.
                      :001
                       (:000
                         (\<lambda>o.
                             :001
                              (:000
                                (\<lambda>p.
                                    :001
                                     (:000
 (\<lambda>q.
     :001
      (:000
        (\<lambda>r.
            :001
             (:000
               (\<lambda>s.
                   :001
                    (:000
                      (\<lambda>t.
                          :001
                           (:000
                             (\<lambda>u.
                                 :001
                                  (:000
                                    (\<lambda>v.
  :001
   (:000
     (\<lambda>w.
         :001
          (:000
            (\<lambda>x.
                :001
                 (:000
                   (\<lambda>y.
                       :001
                        (:000
                          (\<lambda>z.
                              :001
                               (:000
                                 (\<lambda>aa.
                                     :001
(:000
  (\<lambda>ab.
      :001
       (:000
         (\<lambda>ac.
             :001
              (:000
                (\<lambda>ad.
                    :001
                     (:000
                       (\<lambda>ae.
                           :001
                            (:000
                              (\<lambda>af.
                                  :001
                                   (:000
                                     (\<lambda>ag.
   :001
    (:000
      (\<lambda>ah.
          :001
           (:000
             (\<lambda>ai.
                 :001
                  (:000
                    (\<lambda>aj.
                        :001
                         (:000
                           (\<lambda>ak.
                               :001
                                (:000
                                  (\<lambda>al.
:001
 (:000
   (\<lambda>am.
       :001
        (:000
          (\<lambda>an.
              :001
               (:000
                 (\<lambda>ao.
                     :001
                      (:000
                        (\<lambda>ap.
                            :001
                             (:000
                               (\<lambda>aq.
                                   :001
                                    (:000
(\<lambda>ar.
    :001
     (:000
       (\<lambda>as.
           :001
            (:000
              (\<lambda>at.
                  :001
                   (:000
                     (\<lambda>au.
                         :001
                          (:000
                            (\<lambda>av.
                                :001
                                 (:000
                                   (\<lambda>aw.
 :001
  (:000
    (\<lambda>ax.
        :001
         (:000
           (\<lambda>ay.
               :001
                (:000
                  (?T55 a b c d e f g h i j k l m n o p q r s t u v w x y z
                    aa ab ac ad ae af ag ah ai aj ak al am an ao ap aq ar as
                    at au av aw ax
                    ay))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
Enter MATCH
\<lambda>x a b c d e f g h i j k l m n o p q r s t u v w y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az.
   :001
    (:000
      (?\<V>55 a b c d e f g h i j k l m n o p q r s t u v w y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay
        az)) \<equiv>\<^sup>?
\<lambda>x.
   ?\<V>55
    (:000
      (\<lambda>a.
          :001
           (:000
             (\<lambda>b.
                 :001
                  (:000
                    (\<lambda>c.
                        :001
                         (:000
                           (\<lambda>d.
                               :001
                                (:000
                                  (\<lambda>e.
:001
 (:000
   (\<lambda>f.
       :001
        (:000
          (\<lambda>g.
              :001
               (:000
                 (\<lambda>h.
                     :001
                      (:000
                        (\<lambda>i.
                            :001
                             (:000
                               (\<lambda>j.
                                   :001
                                    (:000
(\<lambda>k.
    :001
     (:000
       (\<lambda>l.
           :001
            (:000
              (\<lambda>m.
                  :001
                   (:000
                     (\<lambda>n.
                         :001
                          (:000
                            (\<lambda>o.
                                :001
                                 (:000
                                   (\<lambda>p.
 :001
  (:000
    (\<lambda>q.
        :001
         (:000
           (\<lambda>r.
               :001
                (:000
                  (\<lambda>s.
                      :001
                       (:000
                         (\<lambda>t.
                             :001
                              (:000
                                (\<lambda>u.
                                    :001
                                     (:000
 (\<lambda>v.
     :001
      (:000
        (\<lambda>w.
            :001
             (:000
               (\<lambda>x.
                   :001
                    (:000
                      (\<lambda>y.
                          :001
                           (:000
                             (\<lambda>z.
                                 :001
                                  (:000
                                    (\<lambda>aa.
  :001
   (:000
     (\<lambda>ab.
         :001
          (:000
            (\<lambda>ac.
                :001
                 (:000
                   (\<lambda>ad.
                       :001
                        (:000
                          (\<lambda>ae.
                              :001
                               (:000
                                 (\<lambda>af.
                                     :001
(:000
  (\<lambda>ag.
      :001
       (:000
         (\<lambda>ah.
             :001
              (:000
                (\<lambda>ai.
                    :001
                     (:000
                       (\<lambda>aj.
                           :001
                            (:000
                              (\<lambda>ak.
                                  :001
                                   (:000
                                     (\<lambda>al.
   :001
    (:000
      (\<lambda>am.
          :001
           (:000
             (\<lambda>an.
                 :001
                  (:000
                    (\<lambda>ao.
                        :001
                         (:000
                           (\<lambda>ap.
                               :001
                                (:000
                                  (\<lambda>aq.
:001
 (:000
   (\<lambda>ar.
       :001
        (:000
          (\<lambda>as.
              :001
               (:000
                 (\<lambda>at.
                     :001
                      (:000
                        (\<lambda>au.
                            :001
                             (:000
                               (\<lambda>av.
                                   :001
                                    (:000
(\<lambda>aw.
    :001
     (:000
       (\<lambda>ax.
           :001
            (:000
              (\<lambda>ay.
                  :001
                   (:000
                     (?\<V>55 a b c d e f g h i j k l m n o p q r s t u v w
                       x y z aa ab ac ad ae af ag ah ai aj ak al am an ao ap
                       aq ar as at au av aw ax
                       ay))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
Enter MATCH
\<lambda>a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az.
   :001
    (:000
      (?T56 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay
        az)) \<equiv>\<^sup>?
?T56
 (:000
   (\<lambda>a.
       :001
        (:000
          (\<lambda>b.
              :001
               (:000
                 (\<lambda>c.
                     :001
                      (:000
                        (\<lambda>d.
                            :001
                             (:000
                               (\<lambda>e.
                                   :001
                                    (:000
(\<lambda>f.
    :001
     (:000
       (\<lambda>g.
           :001
            (:000
              (\<lambda>h.
                  :001
                   (:000
                     (\<lambda>i.
                         :001
                          (:000
                            (\<lambda>j.
                                :001
                                 (:000
                                   (\<lambda>k.
 :001
  (:000
    (\<lambda>l.
        :001
         (:000
           (\<lambda>m.
               :001
                (:000
                  (\<lambda>n.
                      :001
                       (:000
                         (\<lambda>o.
                             :001
                              (:000
                                (\<lambda>p.
                                    :001
                                     (:000
 (\<lambda>q.
     :001
      (:000
        (\<lambda>r.
            :001
             (:000
               (\<lambda>s.
                   :001
                    (:000
                      (\<lambda>t.
                          :001
                           (:000
                             (\<lambda>u.
                                 :001
                                  (:000
                                    (\<lambda>v.
  :001
   (:000
     (\<lambda>w.
         :001
          (:000
            (\<lambda>x.
                :001
                 (:000
                   (\<lambda>y.
                       :001
                        (:000
                          (\<lambda>z.
                              :001
                               (:000
                                 (\<lambda>aa.
                                     :001
(:000
  (\<lambda>ab.
      :001
       (:000
         (\<lambda>ac.
             :001
              (:000
                (\<lambda>ad.
                    :001
                     (:000
                       (\<lambda>ae.
                           :001
                            (:000
                              (\<lambda>af.
                                  :001
                                   (:000
                                     (\<lambda>ag.
   :001
    (:000
      (\<lambda>ah.
          :001
           (:000
             (\<lambda>ai.
                 :001
                  (:000
                    (\<lambda>aj.
                        :001
                         (:000
                           (\<lambda>ak.
                               :001
                                (:000
                                  (\<lambda>al.
:001
 (:000
   (\<lambda>am.
       :001
        (:000
          (\<lambda>an.
              :001
               (:000
                 (\<lambda>ao.
                     :001
                      (:000
                        (\<lambda>ap.
                            :001
                             (:000
                               (\<lambda>aq.
                                   :001
                                    (:000
(\<lambda>ar.
    :001
     (:000
       (\<lambda>as.
           :001
            (:000
              (\<lambda>at.
                  :001
                   (:000
                     (\<lambda>au.
                         :001
                          (:000
                            (\<lambda>av.
                                :001
                                 (:000
                                   (\<lambda>aw.
 :001
  (:000
    (\<lambda>ax.
        :001
         (:000
           (\<lambda>ay.
               :001
                (:000
                  (\<lambda>az.
                      :001
                       (:000
                         (?T56 a b c d e f g h i j k l m n o p q r s t u v w
                           x y z aa ab ac ad ae af ag ah ai aj ak al am an
                           ao ap aq ar as at au av aw ax ay
                           az))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
Enter MATCH
\<lambda>a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba.
   :001
    (:000
      (?T57 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az
        ba)) \<equiv>\<^sup>?
?T57
 (:000
   (\<lambda>a.
       :001
        (:000
          (\<lambda>b.
              :001
               (:000
                 (\<lambda>c.
                     :001
                      (:000
                        (\<lambda>d.
                            :001
                             (:000
                               (\<lambda>e.
                                   :001
                                    (:000
(\<lambda>f.
    :001
     (:000
       (\<lambda>g.
           :001
            (:000
              (\<lambda>h.
                  :001
                   (:000
                     (\<lambda>i.
                         :001
                          (:000
                            (\<lambda>j.
                                :001
                                 (:000
                                   (\<lambda>k.
 :001
  (:000
    (\<lambda>l.
        :001
         (:000
           (\<lambda>m.
               :001
                (:000
                  (\<lambda>n.
                      :001
                       (:000
                         (\<lambda>o.
                             :001
                              (:000
                                (\<lambda>p.
                                    :001
                                     (:000
 (\<lambda>q.
     :001
      (:000
        (\<lambda>r.
            :001
             (:000
               (\<lambda>s.
                   :001
                    (:000
                      (\<lambda>t.
                          :001
                           (:000
                             (\<lambda>u.
                                 :001
                                  (:000
                                    (\<lambda>v.
  :001
   (:000
     (\<lambda>w.
         :001
          (:000
            (\<lambda>x.
                :001
                 (:000
                   (\<lambda>y.
                       :001
                        (:000
                          (\<lambda>z.
                              :001
                               (:000
                                 (\<lambda>aa.
                                     :001
(:000
  (\<lambda>ab.
      :001
       (:000
         (\<lambda>ac.
             :001
              (:000
                (\<lambda>ad.
                    :001
                     (:000
                       (\<lambda>ae.
                           :001
                            (:000
                              (\<lambda>af.
                                  :001
                                   (:000
                                     (\<lambda>ag.
   :001
    (:000
      (\<lambda>ah.
          :001
           (:000
             (\<lambda>ai.
                 :001
                  (:000
                    (\<lambda>aj.
                        :001
                         (:000
                           (\<lambda>ak.
                               :001
                                (:000
                                  (\<lambda>al.
:001
 (:000
   (\<lambda>am.
       :001
        (:000
          (\<lambda>an.
              :001
               (:000
                 (\<lambda>ao.
                     :001
                      (:000
                        (\<lambda>ap.
                            :001
                             (:000
                               (\<lambda>aq.
                                   :001
                                    (:000
(\<lambda>ar.
    :001
     (:000
       (\<lambda>as.
           :001
            (:000
              (\<lambda>at.
                  :001
                   (:000
                     (\<lambda>au.
                         :001
                          (:000
                            (\<lambda>av.
                                :001
                                 (:000
                                   (\<lambda>aw.
 :001
  (:000
    (\<lambda>ax.
        :001
         (:000
           (\<lambda>ay.
               :001
                (:000
                  (\<lambda>az.
                      :001
                       (:000
                         (\<lambda>ba.
                             :001
                              (:000
                                (?T57 a b c d e f g h i j k l m n o p q r s
                                  t u v w x y z aa ab ac ad ae af ag ah ai
                                  aj ak al am an ao ap aq ar as at au av aw
                                  ax ay az
                                  ba))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
Enter MATCH
\<lambda>x a b c d e f g h i j k l m n o p q r s t u v w y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba.
   :001
    (:000
      (?\<V>56 a b c d e f g h i j k l m n o p q r s t u v w y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az
        ba)) \<equiv>\<^sup>?
\<lambda>x.
   ?\<V>56
    (:000
      (\<lambda>a.
          :001
           (:000
             (\<lambda>b.
                 :001
                  (:000
                    (\<lambda>c.
                        :001
                         (:000
                           (\<lambda>d.
                               :001
                                (:000
                                  (\<lambda>e.
:001
 (:000
   (\<lambda>f.
       :001
        (:000
          (\<lambda>g.
              :001
               (:000
                 (\<lambda>h.
                     :001
                      (:000
                        (\<lambda>i.
                            :001
                             (:000
                               (\<lambda>j.
                                   :001
                                    (:000
(\<lambda>k.
    :001
     (:000
       (\<lambda>l.
           :001
            (:000
              (\<lambda>m.
                  :001
                   (:000
                     (\<lambda>n.
                         :001
                          (:000
                            (\<lambda>o.
                                :001
                                 (:000
                                   (\<lambda>p.
 :001
  (:000
    (\<lambda>q.
        :001
         (:000
           (\<lambda>r.
               :001
                (:000
                  (\<lambda>s.
                      :001
                       (:000
                         (\<lambda>t.
                             :001
                              (:000
                                (\<lambda>u.
                                    :001
                                     (:000
 (\<lambda>v.
     :001
      (:000
        (\<lambda>w.
            :001
             (:000
               (\<lambda>x.
                   :001
                    (:000
                      (\<lambda>y.
                          :001
                           (:000
                             (\<lambda>z.
                                 :001
                                  (:000
                                    (\<lambda>aa.
  :001
   (:000
     (\<lambda>ab.
         :001
          (:000
            (\<lambda>ac.
                :001
                 (:000
                   (\<lambda>ad.
                       :001
                        (:000
                          (\<lambda>ae.
                              :001
                               (:000
                                 (\<lambda>af.
                                     :001
(:000
  (\<lambda>ag.
      :001
       (:000
         (\<lambda>ah.
             :001
              (:000
                (\<lambda>ai.
                    :001
                     (:000
                       (\<lambda>aj.
                           :001
                            (:000
                              (\<lambda>ak.
                                  :001
                                   (:000
                                     (\<lambda>al.
   :001
    (:000
      (\<lambda>am.
          :001
           (:000
             (\<lambda>an.
                 :001
                  (:000
                    (\<lambda>ao.
                        :001
                         (:000
                           (\<lambda>ap.
                               :001
                                (:000
                                  (\<lambda>aq.
:001
 (:000
   (\<lambda>ar.
       :001
        (:000
          (\<lambda>as.
              :001
               (:000
                 (\<lambda>at.
                     :001
                      (:000
                        (\<lambda>au.
                            :001
                             (:000
                               (\<lambda>av.
                                   :001
                                    (:000
(\<lambda>aw.
    :001
     (:000
       (\<lambda>ax.
           :001
            (:000
              (\<lambda>ay.
                  :001
                   (:000
                     (\<lambda>az.
                         :001
                          (:000
                            (?\<V>56 a b c d e f g h i j k l m n o p q r s t
                              u v w x y z aa ab ac ad ae af ag ah ai aj ak
                              al am an ao ap aq ar as at au av aw ax ay
                              az))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
Enter MATCH
\<lambda>a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba bb.
   :001
    (:000
      (?T58 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba
        bb)) \<equiv>\<^sup>?
?T58
 (:000
   (\<lambda>a.
       :001
        (:000
          (\<lambda>b.
              :001
               (:000
                 (\<lambda>c.
                     :001
                      (:000
                        (\<lambda>d.
                            :001
                             (:000
                               (\<lambda>e.
                                   :001
                                    (:000
(\<lambda>f.
    :001
     (:000
       (\<lambda>g.
           :001
            (:000
              (\<lambda>h.
                  :001
                   (:000
                     (\<lambda>i.
                         :001
                          (:000
                            (\<lambda>j.
                                :001
                                 (:000
                                   (\<lambda>k.
 :001
  (:000
    (\<lambda>l.
        :001
         (:000
           (\<lambda>m.
               :001
                (:000
                  (\<lambda>n.
                      :001
                       (:000
                         (\<lambda>o.
                             :001
                              (:000
                                (\<lambda>p.
                                    :001
                                     (:000
 (\<lambda>q.
     :001
      (:000
        (\<lambda>r.
            :001
             (:000
               (\<lambda>s.
                   :001
                    (:000
                      (\<lambda>t.
                          :001
                           (:000
                             (\<lambda>u.
                                 :001
                                  (:000
                                    (\<lambda>v.
  :001
   (:000
     (\<lambda>w.
         :001
          (:000
            (\<lambda>x.
                :001
                 (:000
                   (\<lambda>y.
                       :001
                        (:000
                          (\<lambda>z.
                              :001
                               (:000
                                 (\<lambda>aa.
                                     :001
(:000
  (\<lambda>ab.
      :001
       (:000
         (\<lambda>ac.
             :001
              (:000
                (\<lambda>ad.
                    :001
                     (:000
                       (\<lambda>ae.
                           :001
                            (:000
                              (\<lambda>af.
                                  :001
                                   (:000
                                     (\<lambda>ag.
   :001
    (:000
      (\<lambda>ah.
          :001
           (:000
             (\<lambda>ai.
                 :001
                  (:000
                    (\<lambda>aj.
                        :001
                         (:000
                           (\<lambda>ak.
                               :001
                                (:000
                                  (\<lambda>al.
:001
 (:000
   (\<lambda>am.
       :001
        (:000
          (\<lambda>an.
              :001
               (:000
                 (\<lambda>ao.
                     :001
                      (:000
                        (\<lambda>ap.
                            :001
                             (:000
                               (\<lambda>aq.
                                   :001
                                    (:000
(\<lambda>ar.
    :001
     (:000
       (\<lambda>as.
           :001
            (:000
              (\<lambda>at.
                  :001
                   (:000
                     (\<lambda>au.
                         :001
                          (:000
                            (\<lambda>av.
                                :001
                                 (:000
                                   (\<lambda>aw.
 :001
  (:000
    (\<lambda>ax.
        :001
         (:000
           (\<lambda>ay.
               :001
                (:000
                  (\<lambda>az.
                      :001
                       (:000
                         (\<lambda>ba.
                             :001
                              (:000
                                (\<lambda>bb.
                                    :001
                                     (:000
 (?T58 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae af
   ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba
   bb))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
Enter MATCH
\<lambda>x a b c d e f g h i j k l m n o p q r s t u v w y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba bb.
   :001
    (:000
      (?\<V>57 a b c d e f g h i j k l m n o p q r s t u v w y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba
        bb)) \<equiv>\<^sup>?
\<lambda>x.
   ?\<V>57
    (:000
      (\<lambda>a.
          :001
           (:000
             (\<lambda>b.
                 :001
                  (:000
                    (\<lambda>c.
                        :001
                         (:000
                           (\<lambda>d.
                               :001
                                (:000
                                  (\<lambda>e.
:001
 (:000
   (\<lambda>f.
       :001
        (:000
          (\<lambda>g.
              :001
               (:000
                 (\<lambda>h.
                     :001
                      (:000
                        (\<lambda>i.
                            :001
                             (:000
                               (\<lambda>j.
                                   :001
                                    (:000
(\<lambda>k.
    :001
     (:000
       (\<lambda>l.
           :001
            (:000
              (\<lambda>m.
                  :001
                   (:000
                     (\<lambda>n.
                         :001
                          (:000
                            (\<lambda>o.
                                :001
                                 (:000
                                   (\<lambda>p.
 :001
  (:000
    (\<lambda>q.
        :001
         (:000
           (\<lambda>r.
               :001
                (:000
                  (\<lambda>s.
                      :001
                       (:000
                         (\<lambda>t.
                             :001
                              (:000
                                (\<lambda>u.
                                    :001
                                     (:000
 (\<lambda>v.
     :001
      (:000
        (\<lambda>w.
            :001
             (:000
               (\<lambda>x.
                   :001
                    (:000
                      (\<lambda>y.
                          :001
                           (:000
                             (\<lambda>z.
                                 :001
                                  (:000
                                    (\<lambda>aa.
  :001
   (:000
     (\<lambda>ab.
         :001
          (:000
            (\<lambda>ac.
                :001
                 (:000
                   (\<lambda>ad.
                       :001
                        (:000
                          (\<lambda>ae.
                              :001
                               (:000
                                 (\<lambda>af.
                                     :001
(:000
  (\<lambda>ag.
      :001
       (:000
         (\<lambda>ah.
             :001
              (:000
                (\<lambda>ai.
                    :001
                     (:000
                       (\<lambda>aj.
                           :001
                            (:000
                              (\<lambda>ak.
                                  :001
                                   (:000
                                     (\<lambda>al.
   :001
    (:000
      (\<lambda>am.
          :001
           (:000
             (\<lambda>an.
                 :001
                  (:000
                    (\<lambda>ao.
                        :001
                         (:000
                           (\<lambda>ap.
                               :001
                                (:000
                                  (\<lambda>aq.
:001
 (:000
   (\<lambda>ar.
       :001
        (:000
          (\<lambda>as.
              :001
               (:000
                 (\<lambda>at.
                     :001
                      (:000
                        (\<lambda>au.
                            :001
                             (:000
                               (\<lambda>av.
                                   :001
                                    (:000
(\<lambda>aw.
    :001
     (:000
       (\<lambda>ax.
           :001
            (:000
              (\<lambda>ay.
                  :001
                   (:000
                     (\<lambda>az.
                         :001
                          (:000
                            (\<lambda>ba.
                                :001
                                 (:000
                                   (?\<V>57 a b c d e f g h i j k l m n o p
                                     q r s t u v w x y z aa ab ac ad ae af
                                     ag ah ai aj ak al am an ao ap aq ar as
                                     at au av aw ax ay az
                                     ba))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
Enter MATCH
### Rule already declared as introduction (intro)
### \<lbrakk>?a \<in> sets ?M; ?b \<in> sets ?M\<rbrakk>
### \<Longrightarrow> ?a - ?b \<in> sets ?M
\<lambda>a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba bb bc.
   :001
    (:000
      (?T59 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba
        bb bc)) \<equiv>\<^sup>?
?T59
 (:000
   (\<lambda>a.
       :001
        (:000
          (\<lambda>b.
              :001
               (:000
                 (\<lambda>c.
                     :001
                      (:000
                        (\<lambda>d.
                            :001
                             (:000
                               (\<lambda>e.
                                   :001
                                    (:000
(\<lambda>f.
    :001
     (:000
       (\<lambda>g.
           :001
            (:000
              (\<lambda>h.
                  :001
                   (:000
                     (\<lambda>i.
                         :001
                          (:000
                            (\<lambda>j.
                                :001
                                 (:000
                                   (\<lambda>k.
 :001
  (:000
    (\<lambda>l.
        :001
         (:000
           (\<lambda>m.
               :001
                (:000
                  (\<lambda>n.
                      :001
                       (:000
                         (\<lambda>o.
                             :001
                              (:000
                                (\<lambda>p.
                                    :001
                                     (:000
 (\<lambda>q.
     :001
      (:000
        (\<lambda>r.
            :001
             (:000
               (\<lambda>s.
                   :001
                    (:000
                      (\<lambda>t.
                          :001
                           (:000
                             (\<lambda>u.
                                 :001
                                  (:000
                                    (\<lambda>v.
  :001
   (:000
     (\<lambda>w.
         :001
          (:000
            (\<lambda>x.
                :001
                 (:000
                   (\<lambda>y.
                       :001
                        (:000
                          (\<lambda>z.
                              :001
                               (:000
                                 (\<lambda>aa.
                                     :001
(:000
  (\<lambda>ab.
      :001
       (:000
         (\<lambda>ac.
             :001
              (:000
                (\<lambda>ad.
                    :001
                     (:000
                       (\<lambda>ae.
                           :001
                            (:000
                              (\<lambda>af.
                                  :001
                                   (:000
                                     (\<lambda>ag.
   :001
    (:000
      (\<lambda>ah.
          :001
           (:000
             (\<lambda>ai.
                 :001
                  (:000
                    (\<lambda>aj.
                        :001
                         (:000
                           (\<lambda>ak.
                               :001
                                (:000
                                  (\<lambda>al.
:001
 (:000
   (\<lambda>am.
       :001
        (:000
          (\<lambda>an.
              :001
               (:000
                 (\<lambda>ao.
                     :001
                      (:000
                        (\<lambda>ap.
                            :001
                             (:000
                               (\<lambda>aq.
                                   :001
                                    (:000
(\<lambda>ar.
    :001
     (:000
       (\<lambda>as.
           :001
            (:000
              (\<lambda>at.
                  :001
                   (:000
                     (\<lambda>au.
                         :001
                          (:000
                            (\<lambda>av.
                                :001
                                 (:000
                                   (\<lambda>aw.
 :001
  (:000
    (\<lambda>ax.
        :001
         (:000
           (\<lambda>ay.
               :001
                (:000
                  (\<lambda>az.
                      :001
                       (:000
                         (\<lambda>ba.
                             :001
                              (:000
                                (\<lambda>bb.
                                    :001
                                     (:000
 (\<lambda>bc.
     :001
      (:000
        (?T59 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac
          ad ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay
          az ba bb
          bc))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
Enter MATCH
\<lambda>x a b c d e f g h i j k l m n o p q r s t u v w y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba bb bc.
   :001
    (:000
      (?\<V>58 a b c d e f g h i j k l m n o p q r s t u v w y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba
        bb bc)) \<equiv>\<^sup>?
\<lambda>x.
   ?\<V>58
    (:000
      (\<lambda>a.
          :001
           (:000
             (\<lambda>b.
                 :001
                  (:000
                    (\<lambda>c.
                        :001
                         (:000
                           (\<lambda>d.
                               :001
                                (:000
                                  (\<lambda>e.
:001
 (:000
   (\<lambda>f.
       :001
        (:000
          (\<lambda>g.
              :001
               (:000
                 (\<lambda>h.
                     :001
                      (:000
                        (\<lambda>i.
                            :001
                             (:000
                               (\<lambda>j.
                                   :001
                                    (:000
(\<lambda>k.
    :001
     (:000
       (\<lambda>l.
           :001
            (:000
              (\<lambda>m.
                  :001
                   (:000
                     (\<lambda>n.
                         :001
                          (:000
                            (\<lambda>o.
                                :001
                                 (:000
                                   (\<lambda>p.
 :001
  (:000
    (\<lambda>q.
        :001
         (:000
           (\<lambda>r.
               :001
                (:000
                  (\<lambda>s.
                      :001
                       (:000
                         (\<lambda>t.
                             :001
                              (:000
                                (\<lambda>u.
                                    :001
                                     (:000
 (\<lambda>v.
     :001
      (:000
        (\<lambda>w.
            :001
             (:000
               (\<lambda>x.
                   :001
                    (:000
                      (\<lambda>y.
                          :001
                           (:000
                             (\<lambda>z.
                                 :001
                                  (:000
                                    (\<lambda>aa.
  :001
   (:000
     (\<lambda>ab.
         :001
          (:000
            (\<lambda>ac.
                :001
                 (:000
                   (\<lambda>ad.
                       :001
                        (:000
                          (\<lambda>ae.
                              :001
                               (:000
                                 (\<lambda>af.
                                     :001
(:000
  (\<lambda>ag.
      :001
       (:000
         (\<lambda>ah.
             :001
              (:000
                (\<lambda>ai.
                    :001
                     (:000
                       (\<lambda>aj.
                           :001
                            (:000
                              (\<lambda>ak.
                                  :001
                                   (:000
                                     (\<lambda>al.
   :001
    (:000
      (\<lambda>am.
          :001
           (:000
             (\<lambda>an.
                 :001
                  (:000
                    (\<lambda>ao.
                        :001
                         (:000
                           (\<lambda>ap.
                               :001
                                (:000
                                  (\<lambda>aq.
:001
 (:000
   (\<lambda>ar.
       :001
        (:000
          (\<lambda>as.
              :001
               (:000
                 (\<lambda>at.
                     :001
                      (:000
                        (\<lambda>au.
                            :001
                             (:000
                               (\<lambda>av.
                                   :001
                                    (:000
(\<lambda>aw.
    :001
     (:000
       (\<lambda>ax.
           :001
            (:000
              (\<lambda>ay.
                  :001
                   (:000
                     (\<lambda>az.
                         :001
                          (:000
                            (\<lambda>ba.
                                :001
                                 (:000
                                   (\<lambda>bb.
 :001
  (:000
    (?\<V>58 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad
      ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba
      bb))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
Enter MATCH
\<lambda>x a b c d e f g h i j k l m n o p q r s t u v w y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba bb bc
   bd.
   :001
    (:000
      (?\<V>59 a b c d e f g h i j k l m n o p q r s t u v w y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba
        bb bc bd)) \<equiv>\<^sup>?
\<lambda>x.
   ?\<V>59
    (:000
      (\<lambda>a.
          :001
           (:000
             (\<lambda>b.
                 :001
                  (:000
                    (\<lambda>c.
                        :001
                         (:000
                           (\<lambda>d.
                               :001
                                (:000
                                  (\<lambda>e.
:001
 (:000
   (\<lambda>f.
       :001
        (:000
          (\<lambda>g.
              :001
               (:000
                 (\<lambda>h.
                     :001
                      (:000
                        (\<lambda>i.
                            :001
                             (:000
                               (\<lambda>j.
                                   :001
                                    (:000
(\<lambda>k.
    :001
     (:000
       (\<lambda>l.
           :001
            (:000
              (\<lambda>m.
                  :001
                   (:000
                     (\<lambda>n.
                         :001
                          (:000
                            (\<lambda>o.
                                :001
                                 (:000
                                   (\<lambda>p.
 :001
  (:000
    (\<lambda>q.
        :001
         (:000
           (\<lambda>r.
               :001
                (:000
                  (\<lambda>s.
                      :001
                       (:000
                         (\<lambda>t.
                             :001
                              (:000
                                (\<lambda>u.
                                    :001
                                     (:000
 (\<lambda>v.
     :001
      (:000
        (\<lambda>w.
            :001
             (:000
               (\<lambda>x.
                   :001
                    (:000
                      (\<lambda>y.
                          :001
                           (:000
                             (\<lambda>z.
                                 :001
                                  (:000
                                    (\<lambda>aa.
  :001
   (:000
     (\<lambda>ab.
         :001
          (:000
            (\<lambda>ac.
                :001
                 (:000
                   (\<lambda>ad.
                       :001
                        (:000
                          (\<lambda>ae.
                              :001
                               (:000
                                 (\<lambda>af.
                                     :001
(:000
  (\<lambda>ag.
      :001
       (:000
         (\<lambda>ah.
             :001
              (:000
                (\<lambda>ai.
                    :001
                     (:000
                       (\<lambda>aj.
                           :001
                            (:000
                              (\<lambda>ak.
                                  :001
                                   (:000
                                     (\<lambda>al.
   :001
    (:000
      (\<lambda>am.
          :001
           (:000
             (\<lambda>an.
                 :001
                  (:000
                    (\<lambda>ao.
                        :001
                         (:000
                           (\<lambda>ap.
                               :001
                                (:000
                                  (\<lambda>aq.
:001
 (:000
   (\<lambda>ar.
       :001
        (:000
          (\<lambda>as.
              :001
               (:000
                 (\<lambda>at.
                     :001
                      (:000
                        (\<lambda>au.
                            :001
                             (:000
                               (\<lambda>av.
                                   :001
                                    (:000
(\<lambda>aw.
    :001
     (:000
       (\<lambda>ax.
           :001
            (:000
              (\<lambda>ay.
                  :001
                   (:000
                     (\<lambda>az.
                         :001
                          (:000
                            (\<lambda>ba.
                                :001
                                 (:000
                                   (\<lambda>bb.
 :001
  (:000
    (\<lambda>bc.
        :001
         (:000
           (?\<V>59 a b c d e f g h i j k l m n o p q r s t u v w x y z aa
             ab ac ad ae af ag ah ai aj ak al am an ao ap aq ar as at au av
             aw ax ay az ba bb
             bc))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
Enter MATCH
\<lambda>a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba bb bc
   bd.
   :001
    (:000
      (?T60 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba
        bb bc bd)) \<equiv>\<^sup>?
?T60
 (:000
   (\<lambda>a.
       :001
        (:000
          (\<lambda>b.
              :001
               (:000
                 (\<lambda>c.
                     :001
                      (:000
                        (\<lambda>d.
                            :001
                             (:000
                               (\<lambda>e.
                                   :001
                                    (:000
(\<lambda>f.
    :001
     (:000
       (\<lambda>g.
           :001
            (:000
              (\<lambda>h.
                  :001
                   (:000
                     (\<lambda>i.
                         :001
                          (:000
                            (\<lambda>j.
                                :001
                                 (:000
                                   (\<lambda>k.
 :001
  (:000
    (\<lambda>l.
        :001
         (:000
           (\<lambda>m.
               :001
                (:000
                  (\<lambda>n.
                      :001
                       (:000
                         (\<lambda>o.
                             :001
                              (:000
                                (\<lambda>p.
                                    :001
                                     (:000
 (\<lambda>q.
     :001
      (:000
        (\<lambda>r.
            :001
             (:000
               (\<lambda>s.
                   :001
                    (:000
                      (\<lambda>t.
                          :001
                           (:000
                             (\<lambda>u.
                                 :001
                                  (:000
                                    (\<lambda>v.
  :001
   (:000
     (\<lambda>w.
         :001
          (:000
            (\<lambda>x.
                :001
                 (:000
                   (\<lambda>y.
                       :001
                        (:000
                          (\<lambda>z.
                              :001
                               (:000
                                 (\<lambda>aa.
                                     :001
(:000
  (\<lambda>ab.
      :001
       (:000
         (\<lambda>ac.
             :001
              (:000
                (\<lambda>ad.
                    :001
                     (:000
                       (\<lambda>ae.
                           :001
                            (:000
                              (\<lambda>af.
                                  :001
                                   (:000
                                     (\<lambda>ag.
   :001
    (:000
      (\<lambda>ah.
          :001
           (:000
             (\<lambda>ai.
                 :001
                  (:000
                    (\<lambda>aj.
                        :001
                         (:000
                           (\<lambda>ak.
                               :001
                                (:000
                                  (\<lambda>al.
:001
 (:000
   (\<lambda>am.
       :001
        (:000
          (\<lambda>an.
              :001
               (:000
                 (\<lambda>ao.
                     :001
                      (:000
                        (\<lambda>ap.
                            :001
                             (:000
                               (\<lambda>aq.
                                   :001
                                    (:000
(\<lambda>ar.
    :001
     (:000
       (\<lambda>as.
           :001
            (:000
              (\<lambda>at.
                  :001
                   (:000
                     (\<lambda>au.
                         :001
                          (:000
                            (\<lambda>av.
                                :001
                                 (:000
                                   (\<lambda>aw.
 :001
  (:000
    (\<lambda>ax.
        :001
         (:000
           (\<lambda>ay.
               :001
                (:000
                  (\<lambda>az.
                      :001
                       (:000
                         (\<lambda>ba.
                             :001
                              (:000
                                (\<lambda>bb.
                                    :001
                                     (:000
 (\<lambda>bc.
     :001
      (:000
        (\<lambda>bd.
            :001
             (:000
               (?T60 a b c d e f g h i j k l m n o p q r s t u v w x y z aa
                 ab ac ad ae af ag ah ai aj ak al am an ao ap aq ar as at au
                 av aw ax ay az ba bb bc
                 bd))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
Enter MATCH
\<lambda>x a b c d e f g h i j k l m n o p q r s t u v w y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba bb bc
   bd be.
   :001
    (:000
      (?\<V>60 a b c d e f g h i j k l m n o p q r s t u v w y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba
        bb bc bd be)) \<equiv>\<^sup>?
\<lambda>x.
   ?\<V>60
    (:000
      (\<lambda>a.
          :001
           (:000
             (\<lambda>b.
                 :001
                  (:000
                    (\<lambda>c.
                        :001
                         (:000
                           (\<lambda>d.
                               :001
                                (:000
                                  (\<lambda>e.
:001
 (:000
   (\<lambda>f.
       :001
        (:000
          (\<lambda>g.
              :001
               (:000
                 (\<lambda>h.
                     :001
                      (:000
                        (\<lambda>i.
                            :001
                             (:000
                               (\<lambda>j.
                                   :001
                                    (:000
(\<lambda>k.
    :001
     (:000
       (\<lambda>l.
           :001
            (:000
              (\<lambda>m.
                  :001
                   (:000
                     (\<lambda>n.
                         :001
                          (:000
                            (\<lambda>o.
                                :001
                                 (:000
                                   (\<lambda>p.
 :001
  (:000
    (\<lambda>q.
        :001
         (:000
           (\<lambda>r.
               :001
                (:000
                  (\<lambda>s.
                      :001
                       (:000
                         (\<lambda>t.
                             :001
                              (:000
                                (\<lambda>u.
                                    :001
                                     (:000
 (\<lambda>v.
     :001
      (:000
        (\<lambda>w.
            :001
             (:000
               (\<lambda>x.
                   :001
                    (:000
                      (\<lambda>y.
                          :001
                           (:000
                             (\<lambda>z.
                                 :001
                                  (:000
                                    (\<lambda>aa.
  :001
   (:000
     (\<lambda>ab.
         :001
          (:000
            (\<lambda>ac.
                :001
                 (:000
                   (\<lambda>ad.
                       :001
                        (:000
                          (\<lambda>ae.
                              :001
                               (:000
                                 (\<lambda>af.
                                     :001
(:000
  (\<lambda>ag.
      :001
       (:000
         (\<lambda>ah.
             :001
              (:000
                (\<lambda>ai.
                    :001
                     (:000
                       (\<lambda>aj.
                           :001
                            (:000
                              (\<lambda>ak.
                                  :001
                                   (:000
                                     (\<lambda>al.
   :001
    (:000
      (\<lambda>am.
          :001
           (:000
             (\<lambda>an.
                 :001
                  (:000
                    (\<lambda>ao.
                        :001
                         (:000
                           (\<lambda>ap.
                               :001
                                (:000
                                  (\<lambda>aq.
:001
 (:000
   (\<lambda>ar.
       :001
        (:000
          (\<lambda>as.
              :001
               (:000
                 (\<lambda>at.
                     :001
                      (:000
                        (\<lambda>au.
                            :001
                             (:000
                               (\<lambda>av.
                                   :001
                                    (:000
(\<lambda>aw.
    :001
     (:000
       (\<lambda>ax.
           :001
            (:000
              (\<lambda>ay.
                  :001
                   (:000
                     (\<lambda>az.
                         :001
                          (:000
                            (\<lambda>ba.
                                :001
                                 (:000
                                   (\<lambda>bb.
 :001
  (:000
    (\<lambda>bc.
        :001
         (:000
           (\<lambda>bd.
               :001
                (:000
                  (?\<V>60 a b c d e f g h i j k l m n o p q r s t u v w x y
                    z aa ab ac ad ae af ag ah ai aj ak al am an ao ap aq ar
                    as at au av aw ax ay az ba bb bc
                    bd))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
Enter MATCH
\<lambda>a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba bb bc
   bd be.
   :001
    (:000
      (?T61 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba
        bb bc bd be)) \<equiv>\<^sup>?
?T61
 (:000
   (\<lambda>a.
       :001
        (:000
          (\<lambda>b.
              :001
               (:000
                 (\<lambda>c.
                     :001
                      (:000
                        (\<lambda>d.
                            :001
                             (:000
                               (\<lambda>e.
                                   :001
                                    (:000
(\<lambda>f.
    :001
     (:000
       (\<lambda>g.
           :001
            (:000
              (\<lambda>h.
                  :001
                   (:000
                     (\<lambda>i.
                         :001
                          (:000
                            (\<lambda>j.
                                :001
                                 (:000
                                   (\<lambda>k.
 :001
  (:000
    (\<lambda>l.
        :001
         (:000
           (\<lambda>m.
               :001
                (:000
                  (\<lambda>n.
                      :001
                       (:000
                         (\<lambda>o.
                             :001
                              (:000
                                (\<lambda>p.
                                    :001
                                     (:000
 (\<lambda>q.
     :001
      (:000
        (\<lambda>r.
            :001
             (:000
               (\<lambda>s.
                   :001
                    (:000
                      (\<lambda>t.
                          :001
                           (:000
                             (\<lambda>u.
                                 :001
                                  (:000
                                    (\<lambda>v.
  :001
   (:000
     (\<lambda>w.
         :001
          (:000
            (\<lambda>x.
                :001
                 (:000
                   (\<lambda>y.
                       :001
                        (:000
                          (\<lambda>z.
                              :001
                               (:000
                                 (\<lambda>aa.
                                     :001
(:000
  (\<lambda>ab.
      :001
       (:000
         (\<lambda>ac.
             :001
              (:000
                (\<lambda>ad.
                    :001
                     (:000
                       (\<lambda>ae.
                           :001
                            (:000
                              (\<lambda>af.
                                  :001
                                   (:000
                                     (\<lambda>ag.
   :001
    (:000
      (\<lambda>ah.
          :001
           (:000
             (\<lambda>ai.
                 :001
                  (:000
                    (\<lambda>aj.
                        :001
                         (:000
                           (\<lambda>ak.
                               :001
                                (:000
                                  (\<lambda>al.
:001
 (:000
   (\<lambda>am.
       :001
        (:000
          (\<lambda>an.
              :001
               (:000
                 (\<lambda>ao.
                     :001
                      (:000
                        (\<lambda>ap.
                            :001
                             (:000
                               (\<lambda>aq.
                                   :001
                                    (:000
(\<lambda>ar.
    :001
     (:000
       (\<lambda>as.
           :001
            (:000
              (\<lambda>at.
                  :001
                   (:000
                     (\<lambda>au.
                         :001
                          (:000
                            (\<lambda>av.
                                :001
                                 (:000
                                   (\<lambda>aw.
 :001
  (:000
    (\<lambda>ax.
        :001
         (:000
           (\<lambda>ay.
               :001
                (:000
                  (\<lambda>az.
                      :001
                       (:000
                         (\<lambda>ba.
                             :001
                              (:000
                                (\<lambda>bb.
                                    :001
                                     (:000
 (\<lambda>bc.
     :001
      (:000
        (\<lambda>bd.
            :001
             (:000
               (\<lambda>be.
                   :001
                    (:000
                      (?T61 a b c d e f g h i j k l m n o p q r s t u v w x
                        y z aa ab ac ad ae af ag ah ai aj ak al am an ao ap
                        aq ar as at au av aw ax ay az ba bb bc bd
                        be))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
Enter MATCH
\<lambda>x a b c d e f g h i j k l m n o p q r s t u v w y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba bb bc
   bd be bf.
   :001
    (:000
      (?\<V>61 a b c d e f g h i j k l m n o p q r s t u v w y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba
        bb bc bd be bf)) \<equiv>\<^sup>?
\<lambda>x.
   ?\<V>61
    (:000
      (\<lambda>a.
          :001
           (:000
             (\<lambda>b.
                 :001
                  (:000
                    (\<lambda>c.
                        :001
                         (:000
                           (\<lambda>d.
                               :001
                                (:000
                                  (\<lambda>e.
:001
 (:000
   (\<lambda>f.
       :001
        (:000
          (\<lambda>g.
              :001
               (:000
                 (\<lambda>h.
                     :001
                      (:000
                        (\<lambda>i.
                            :001
                             (:000
                               (\<lambda>j.
                                   :001
                                    (:000
(\<lambda>k.
    :001
     (:000
       (\<lambda>l.
           :001
            (:000
              (\<lambda>m.
                  :001
                   (:000
                     (\<lambda>n.
                         :001
                          (:000
                            (\<lambda>o.
                                :001
                                 (:000
                                   (\<lambda>p.
 :001
  (:000
    (\<lambda>q.
        :001
         (:000
           (\<lambda>r.
               :001
                (:000
                  (\<lambda>s.
                      :001
                       (:000
                         (\<lambda>t.
                             :001
                              (:000
                                (\<lambda>u.
                                    :001
                                     (:000
 (\<lambda>v.
     :001
      (:000
        (\<lambda>w.
            :001
             (:000
               (\<lambda>x.
                   :001
                    (:000
                      (\<lambda>y.
                          :001
                           (:000
                             (\<lambda>z.
                                 :001
                                  (:000
                                    (\<lambda>aa.
  :001
   (:000
     (\<lambda>ab.
         :001
          (:000
            (\<lambda>ac.
                :001
                 (:000
                   (\<lambda>ad.
                       :001
                        (:000
                          (\<lambda>ae.
                              :001
                               (:000
                                 (\<lambda>af.
                                     :001
(:000
  (\<lambda>ag.
      :001
       (:000
         (\<lambda>ah.
             :001
              (:000
                (\<lambda>ai.
                    :001
                     (:000
                       (\<lambda>aj.
                           :001
                            (:000
                              (\<lambda>ak.
                                  :001
                                   (:000
                                     (\<lambda>al.
   :001
    (:000
      (\<lambda>am.
          :001
           (:000
             (\<lambda>an.
                 :001
                  (:000
                    (\<lambda>ao.
                        :001
                         (:000
                           (\<lambda>ap.
                               :001
                                (:000
                                  (\<lambda>aq.
:001
 (:000
   (\<lambda>ar.
       :001
        (:000
          (\<lambda>as.
              :001
               (:000
                 (\<lambda>at.
                     :001
                      (:000
                        (\<lambda>au.
                            :001
                             (:000
                               (\<lambda>av.
                                   :001
                                    (:000
(\<lambda>aw.
    :001
     (:000
       (\<lambda>ax.
           :001
            (:000
              (\<lambda>ay.
                  :001
                   (:000
                     (\<lambda>az.
                         :001
                          (:000
                            (\<lambda>ba.
                                :001
                                 (:000
                                   (\<lambda>bb.
 :001
  (:000
    (\<lambda>bc.
        :001
         (:000
           (\<lambda>bd.
               :001
                (:000
                  (\<lambda>be.
                      :001
                       (:000
                         (?\<V>61 a b c d e f g h i j k l m n o p q r s t u
                           v w x y z aa ab ac ad ae af ag ah ai aj ak al am
                           an ao ap aq ar as at au av aw ax ay az ba bb bc
                           bd be))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
Enter MATCH
\<lambda>a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba bb bc
   bd be bf.
   :001
    (:000
      (?T62 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba
        bb bc bd be bf)) \<equiv>\<^sup>?
?T62
 (:000
   (\<lambda>a.
       :001
        (:000
          (\<lambda>b.
              :001
               (:000
                 (\<lambda>c.
                     :001
                      (:000
                        (\<lambda>d.
                            :001
                             (:000
                               (\<lambda>e.
                                   :001
                                    (:000
(\<lambda>f.
    :001
     (:000
       (\<lambda>g.
           :001
            (:000
              (\<lambda>h.
                  :001
                   (:000
                     (\<lambda>i.
                         :001
                          (:000
                            (\<lambda>j.
                                :001
                                 (:000
                                   (\<lambda>k.
 :001
  (:000
    (\<lambda>l.
        :001
         (:000
           (\<lambda>m.
               :001
                (:000
                  (\<lambda>n.
                      :001
                       (:000
                         (\<lambda>o.
                             :001
                              (:000
                                (\<lambda>p.
                                    :001
                                     (:000
 (\<lambda>q.
     :001
      (:000
        (\<lambda>r.
            :001
             (:000
               (\<lambda>s.
                   :001
                    (:000
                      (\<lambda>t.
                          :001
                           (:000
                             (\<lambda>u.
                                 :001
                                  (:000
                                    (\<lambda>v.
  :001
   (:000
     (\<lambda>w.
         :001
          (:000
            (\<lambda>x.
                :001
                 (:000
                   (\<lambda>y.
                       :001
                        (:000
                          (\<lambda>z.
                              :001
                               (:000
                                 (\<lambda>aa.
                                     :001
(:000
  (\<lambda>ab.
      :001
       (:000
         (\<lambda>ac.
             :001
              (:000
                (\<lambda>ad.
                    :001
                     (:000
                       (\<lambda>ae.
                           :001
                            (:000
                              (\<lambda>af.
                                  :001
                                   (:000
                                     (\<lambda>ag.
   :001
    (:000
      (\<lambda>ah.
          :001
           (:000
             (\<lambda>ai.
                 :001
                  (:000
                    (\<lambda>aj.
                        :001
                         (:000
                           (\<lambda>ak.
                               :001
                                (:000
                                  (\<lambda>al.
:001
 (:000
   (\<lambda>am.
       :001
        (:000
          (\<lambda>an.
              :001
               (:000
                 (\<lambda>ao.
                     :001
                      (:000
                        (\<lambda>ap.
                            :001
                             (:000
                               (\<lambda>aq.
                                   :001
                                    (:000
(\<lambda>ar.
    :001
     (:000
       (\<lambda>as.
           :001
            (:000
              (\<lambda>at.
                  :001
                   (:000
                     (\<lambda>au.
                         :001
                          (:000
                            (\<lambda>av.
                                :001
                                 (:000
                                   (\<lambda>aw.
 :001
  (:000
    (\<lambda>ax.
        :001
         (:000
           (\<lambda>ay.
               :001
                (:000
                  (\<lambda>az.
                      :001
                       (:000
                         (\<lambda>ba.
                             :001
                              (:000
                                (\<lambda>bb.
                                    :001
                                     (:000
 (\<lambda>bc.
     :001
      (:000
        (\<lambda>bd.
            :001
             (:000
               (\<lambda>be.
                   :001
                    (:000
                      (\<lambda>bf.
                          :001
                           (:000
                             (?T62 a b c d e f g h i j k l m n o p q r s t u
                               v w x y z aa ab ac ad ae af ag ah ai aj ak al
                               am an ao ap aq ar as at au av aw ax ay az ba
                               bb bc bd be
                               bf))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
Enter MATCH
\<lambda>x a b c d e f g h i j k l m n o p q r s t u v w y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba bb bc
   bd be bf bg.
   :001
    (:000
      (?\<V>62 a b c d e f g h i j k l m n o p q r s t u v w y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba
        bb bc bd be bf bg)) \<equiv>\<^sup>?
\<lambda>x.
   ?\<V>62
    (:000
      (\<lambda>a.
          :001
           (:000
             (\<lambda>b.
                 :001
                  (:000
                    (\<lambda>c.
                        :001
                         (:000
                           (\<lambda>d.
                               :001
                                (:000
                                  (\<lambda>e.
:001
 (:000
   (\<lambda>f.
       :001
        (:000
          (\<lambda>g.
              :001
               (:000
                 (\<lambda>h.
                     :001
                      (:000
                        (\<lambda>i.
                            :001
                             (:000
                               (\<lambda>j.
                                   :001
                                    (:000
(\<lambda>k.
    :001
     (:000
       (\<lambda>l.
           :001
            (:000
              (\<lambda>m.
                  :001
                   (:000
                     (\<lambda>n.
                         :001
                          (:000
                            (\<lambda>o.
                                :001
                                 (:000
                                   (\<lambda>p.
 :001
  (:000
    (\<lambda>q.
        :001
         (:000
           (\<lambda>r.
               :001
                (:000
                  (\<lambda>s.
                      :001
                       (:000
                         (\<lambda>t.
                             :001
                              (:000
                                (\<lambda>u.
                                    :001
                                     (:000
 (\<lambda>v.
     :001
      (:000
        (\<lambda>w.
            :001
             (:000
               (\<lambda>x.
                   :001
                    (:000
                      (\<lambda>y.
                          :001
                           (:000
                             (\<lambda>z.
                                 :001
                                  (:000
                                    (\<lambda>aa.
  :001
   (:000
     (\<lambda>ab.
         :001
          (:000
            (\<lambda>ac.
                :001
                 (:000
                   (\<lambda>ad.
                       :001
                        (:000
                          (\<lambda>ae.
                              :001
                               (:000
                                 (\<lambda>af.
                                     :001
(:000
  (\<lambda>ag.
      :001
       (:000
         (\<lambda>ah.
             :001
              (:000
                (\<lambda>ai.
                    :001
                     (:000
                       (\<lambda>aj.
                           :001
                            (:000
                              (\<lambda>ak.
                                  :001
                                   (:000
                                     (\<lambda>al.
   :001
    (:000
      (\<lambda>am.
          :001
           (:000
             (\<lambda>an.
                 :001
                  (:000
                    (\<lambda>ao.
                        :001
                         (:000
                           (\<lambda>ap.
                               :001
                                (:000
                                  (\<lambda>aq.
:001
 (:000
   (\<lambda>ar.
       :001
        (:000
          (\<lambda>as.
              :001
               (:000
                 (\<lambda>at.
                     :001
                      (:000
                        (\<lambda>au.
                            :001
                             (:000
                               (\<lambda>av.
                                   :001
                                    (:000
(\<lambda>aw.
    :001
     (:000
       (\<lambda>ax.
           :001
            (:000
              (\<lambda>ay.
                  :001
                   (:000
                     (\<lambda>az.
                         :001
                          (:000
                            (\<lambda>ba.
                                :001
                                 (:000
                                   (\<lambda>bb.
 :001
  (:000
    (\<lambda>bc.
        :001
         (:000
           (\<lambda>bd.
               :001
                (:000
                  (\<lambda>be.
                      :001
                       (:000
                         (\<lambda>bf.
                             :001
                              (:000
                                (?\<V>62 a b c d e f g h i j k l m n o p q r
                                  s t u v w x y z aa ab ac ad ae af ag ah ai
                                  aj ak al am an ao ap aq ar as at au av aw
                                  ax ay az ba bb bc bd be
                                  bf))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
Enter MATCH
\<lambda>a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba bb bc
   bd be bf bg.
   :001
    (:000
      (?T63 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba
        bb bc bd be bf bg)) \<equiv>\<^sup>?
?T63
 (:000
   (\<lambda>a.
       :001
        (:000
          (\<lambda>b.
              :001
               (:000
                 (\<lambda>c.
                     :001
                      (:000
                        (\<lambda>d.
                            :001
                             (:000
                               (\<lambda>e.
                                   :001
                                    (:000
(\<lambda>f.
    :001
     (:000
       (\<lambda>g.
           :001
            (:000
              (\<lambda>h.
                  :001
                   (:000
                     (\<lambda>i.
                         :001
                          (:000
                            (\<lambda>j.
                                :001
                                 (:000
                                   (\<lambda>k.
 :001
  (:000
    (\<lambda>l.
        :001
         (:000
           (\<lambda>m.
               :001
                (:000
                  (\<lambda>n.
                      :001
                       (:000
                         (\<lambda>o.
                             :001
                              (:000
                                (\<lambda>p.
                                    :001
                                     (:000
 (\<lambda>q.
     :001
      (:000
        (\<lambda>r.
            :001
             (:000
               (\<lambda>s.
                   :001
                    (:000
                      (\<lambda>t.
                          :001
                           (:000
                             (\<lambda>u.
                                 :001
                                  (:000
                                    (\<lambda>v.
  :001
   (:000
     (\<lambda>w.
         :001
          (:000
            (\<lambda>x.
                :001
                 (:000
                   (\<lambda>y.
                       :001
                        (:000
                          (\<lambda>z.
                              :001
                               (:000
                                 (\<lambda>aa.
                                     :001
(:000
  (\<lambda>ab.
      :001
       (:000
         (\<lambda>ac.
             :001
              (:000
                (\<lambda>ad.
                    :001
                     (:000
                       (\<lambda>ae.
                           :001
                            (:000
                              (\<lambda>af.
                                  :001
                                   (:000
                                     (\<lambda>ag.
   :001
    (:000
      (\<lambda>ah.
          :001
           (:000
             (\<lambda>ai.
                 :001
                  (:000
                    (\<lambda>aj.
                        :001
                         (:000
                           (\<lambda>ak.
                               :001
                                (:000
                                  (\<lambda>al.
:001
 (:000
   (\<lambda>am.
       :001
        (:000
          (\<lambda>an.
              :001
               (:000
                 (\<lambda>ao.
                     :001
                      (:000
                        (\<lambda>ap.
                            :001
                             (:000
                               (\<lambda>aq.
                                   :001
                                    (:000
(\<lambda>ar.
    :001
     (:000
       (\<lambda>as.
           :001
            (:000
              (\<lambda>at.
                  :001
                   (:000
                     (\<lambda>au.
                         :001
                          (:000
                            (\<lambda>av.
                                :001
                                 (:000
                                   (\<lambda>aw.
 :001
  (:000
    (\<lambda>ax.
        :001
         (:000
           (\<lambda>ay.
               :001
                (:000
                  (\<lambda>az.
                      :001
                       (:000
                         (\<lambda>ba.
                             :001
                              (:000
                                (\<lambda>bb.
                                    :001
                                     (:000
 (\<lambda>bc.
     :001
      (:000
        (\<lambda>bd.
            :001
             (:000
               (\<lambda>be.
                   :001
                    (:000
                      (\<lambda>bf.
                          :001
                           (:000
                             (\<lambda>bg.
                                 :001
                                  (:000
                                    (?T63 a b c d e f g h i j k l m n o p q
r s t u v w x y z aa ab ac ad ae af ag ah ai aj ak al am an ao ap aq ar as
at au av aw ax ay az ba bb bc bd be bf
bg))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
Enter MATCH
\<lambda>x a b c d e f g h i j k l m n o p q r s t u v w y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba bb bc
   bd be bf bg bh.
   :001
    (:000
      (?\<V>63 a b c d e f g h i j k l m n o p q r s t u v w y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba
        bb bc bd be bf bg bh)) \<equiv>\<^sup>?
\<lambda>x.
   ?\<V>63
    (:000
      (\<lambda>a.
          :001
           (:000
             (\<lambda>b.
                 :001
                  (:000
                    (\<lambda>c.
                        :001
                         (:000
                           (\<lambda>d.
                               :001
                                (:000
                                  (\<lambda>e.
:001
 (:000
   (\<lambda>f.
       :001
        (:000
          (\<lambda>g.
              :001
               (:000
                 (\<lambda>h.
                     :001
                      (:000
                        (\<lambda>i.
                            :001
                             (:000
                               (\<lambda>j.
                                   :001
                                    (:000
(\<lambda>k.
    :001
     (:000
       (\<lambda>l.
           :001
            (:000
              (\<lambda>m.
                  :001
                   (:000
                     (\<lambda>n.
                         :001
                          (:000
                            (\<lambda>o.
                                :001
                                 (:000
                                   (\<lambda>p.
 :001
  (:000
    (\<lambda>q.
        :001
         (:000
           (\<lambda>r.
               :001
                (:000
                  (\<lambda>s.
                      :001
                       (:000
                         (\<lambda>t.
                             :001
                              (:000
                                (\<lambda>u.
                                    :001
                                     (:000
 (\<lambda>v.
     :001
      (:000
        (\<lambda>w.
            :001
             (:000
               (\<lambda>x.
                   :001
                    (:000
                      (\<lambda>y.
                          :001
                           (:000
                             (\<lambda>z.
                                 :001
                                  (:000
                                    (\<lambda>aa.
  :001
   (:000
     (\<lambda>ab.
         :001
          (:000
            (\<lambda>ac.
                :001
                 (:000
                   (\<lambda>ad.
                       :001
                        (:000
                          (\<lambda>ae.
                              :001
                               (:000
                                 (\<lambda>af.
                                     :001
(:000
  (\<lambda>ag.
      :001
       (:000
         (\<lambda>ah.
             :001
              (:000
                (\<lambda>ai.
                    :001
                     (:000
                       (\<lambda>aj.
                           :001
                            (:000
                              (\<lambda>ak.
                                  :001
                                   (:000
                                     (\<lambda>al.
   :001
    (:000
      (\<lambda>am.
          :001
           (:000
             (\<lambda>an.
                 :001
                  (:000
                    (\<lambda>ao.
                        :001
                         (:000
                           (\<lambda>ap.
                               :001
                                (:000
                                  (\<lambda>aq.
:001
 (:000
   (\<lambda>ar.
       :001
        (:000
          (\<lambda>as.
              :001
               (:000
                 (\<lambda>at.
                     :001
                      (:000
                        (\<lambda>au.
                            :001
                             (:000
                               (\<lambda>av.
                                   :001
                                    (:000
(\<lambda>aw.
    :001
     (:000
       (\<lambda>ax.
           :001
            (:000
              (\<lambda>ay.
                  :001
                   (:000
                     (\<lambda>az.
                         :001
                          (:000
                            (\<lambda>ba.
                                :001
                                 (:000
                                   (\<lambda>bb.
 :001
  (:000
    (\<lambda>bc.
        :001
         (:000
           (\<lambda>bd.
               :001
                (:000
                  (\<lambda>be.
                      :001
                       (:000
                         (\<lambda>bf.
                             :001
                              (:000
                                (\<lambda>bg.
                                    :001
                                     (:000
 (?\<V>63 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba bb bc
   bd be bf
   bg))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
Enter MATCH
\<lambda>a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba bb bc
   bd be bf bg bh.
   :001
    (:000
      (?T64 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba
        bb bc bd be bf bg bh)) \<equiv>\<^sup>?
?T64
 (:000
   (\<lambda>a.
       :001
        (:000
          (\<lambda>b.
              :001
               (:000
                 (\<lambda>c.
                     :001
                      (:000
                        (\<lambda>d.
                            :001
                             (:000
                               (\<lambda>e.
                                   :001
                                    (:000
(\<lambda>f.
    :001
     (:000
       (\<lambda>g.
           :001
            (:000
              (\<lambda>h.
                  :001
                   (:000
                     (\<lambda>i.
                         :001
                          (:000
                            (\<lambda>j.
                                :001
                                 (:000
                                   (\<lambda>k.
 :001
  (:000
    (\<lambda>l.
        :001
         (:000
           (\<lambda>m.
               :001
                (:000
                  (\<lambda>n.
                      :001
                       (:000
                         (\<lambda>o.
                             :001
                              (:000
                                (\<lambda>p.
                                    :001
                                     (:000
 (\<lambda>q.
     :001
      (:000
        (\<lambda>r.
            :001
             (:000
               (\<lambda>s.
                   :001
                    (:000
                      (\<lambda>t.
                          :001
                           (:000
                             (\<lambda>u.
                                 :001
                                  (:000
                                    (\<lambda>v.
  :001
   (:000
     (\<lambda>w.
         :001
          (:000
            (\<lambda>x.
                :001
                 (:000
                   (\<lambda>y.
                       :001
                        (:000
                          (\<lambda>z.
                              :001
                               (:000
                                 (\<lambda>aa.
                                     :001
(:000
  (\<lambda>ab.
      :001
       (:000
         (\<lambda>ac.
             :001
              (:000
                (\<lambda>ad.
                    :001
                     (:000
                       (\<lambda>ae.
                           :001
                            (:000
                              (\<lambda>af.
                                  :001
                                   (:000
                                     (\<lambda>ag.
   :001
    (:000
      (\<lambda>ah.
          :001
           (:000
             (\<lambda>ai.
                 :001
                  (:000
                    (\<lambda>aj.
                        :001
                         (:000
                           (\<lambda>ak.
                               :001
                                (:000
                                  (\<lambda>al.
:001
 (:000
   (\<lambda>am.
       :001
        (:000
          (\<lambda>an.
              :001
               (:000
                 (\<lambda>ao.
                     :001
                      (:000
                        (\<lambda>ap.
                            :001
                             (:000
                               (\<lambda>aq.
                                   :001
                                    (:000
(\<lambda>ar.
    :001
     (:000
       (\<lambda>as.
           :001
            (:000
              (\<lambda>at.
                  :001
                   (:000
                     (\<lambda>au.
                         :001
                          (:000
                            (\<lambda>av.
                                :001
                                 (:000
                                   (\<lambda>aw.
 :001
  (:000
    (\<lambda>ax.
        :001
         (:000
           (\<lambda>ay.
               :001
                (:000
                  (\<lambda>az.
                      :001
                       (:000
                         (\<lambda>ba.
                             :001
                              (:000
                                (\<lambda>bb.
                                    :001
                                     (:000
 (\<lambda>bc.
     :001
      (:000
        (\<lambda>bd.
            :001
             (:000
               (\<lambda>be.
                   :001
                    (:000
                      (\<lambda>bf.
                          :001
                           (:000
                             (\<lambda>bg.
                                 :001
                                  (:000
                                    (\<lambda>bh.
  :001
   (:000
     (?T64 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad
       ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba
       bb bc bd be bf bg
       bh))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
### Unification bound exceeded
Failure node
Enter MATCH
### Ignoring duplicate rewrite rule:
### of_nat (?m1 ^ ?n1) \<equiv> of_nat ?m1 ^ ?n1
\<lambda>a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax.
   :001
    (:000
      (?T53 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw
        ax)) \<equiv>\<^sup>?
?T53
 (:000
   (\<lambda>a.
       :001
        (:000
          (\<lambda>b.
              :001
               (:000
                 (\<lambda>c.
                     :001
                      (:000
                        (\<lambda>d.
                            :001
                             (:000
                               (\<lambda>e.
                                   :001
                                    (:000
(\<lambda>f.
    :001
     (:000
       (\<lambda>g.
           :001
            (:000
              (\<lambda>h.
                  :001
                   (:000
                     (\<lambda>i.
                         :001
                          (:000
                            (\<lambda>j.
                                :001
                                 (:000
                                   (\<lambda>k.
 :001
  (:000
    (\<lambda>l.
        :001
         (:000
           (\<lambda>m.
               :001
                (:000
                  (\<lambda>n.
                      :001
                       (:000
                         (\<lambda>o.
                             :001
                              (:000
                                (\<lambda>p.
                                    :001
                                     (:000
 (\<lambda>q.
     :001
      (:000
        (\<lambda>r.
            :001
             (:000
               (\<lambda>s.
                   :001
                    (:000
                      (\<lambda>t.
                          :001
                           (:000
                             (\<lambda>u.
                                 :001
                                  (:000
                                    (\<lambda>v.
  :001
   (:000
     (\<lambda>w.
         :001
          (:000
            (\<lambda>x.
                :001
                 (:000
                   (\<lambda>y.
                       :001
                        (:000
                          (\<lambda>z.
                              :001
                               (:000
                                 (\<lambda>aa.
                                     :001
(:000
  (\<lambda>ab.
      :001
       (:000
         (\<lambda>ac.
             :001
              (:000
                (\<lambda>ad.
                    :001
                     (:000
                       (\<lambda>ae.
                           :001
                            (:000
                              (\<lambda>af.
                                  :001
                                   (:000
                                     (\<lambda>ag.
   :001
    (:000
      (\<lambda>ah.
          :001
           (:000
             (\<lambda>ai.
                 :001
                  (:000
                    (\<lambda>aj.
                        :001
                         (:000
                           (\<lambda>ak.
                               :001
                                (:000
                                  (\<lambda>al.
:001
 (:000
   (\<lambda>am.
       :001
        (:000
          (\<lambda>an.
              :001
               (:000
                 (\<lambda>ao.
                     :001
                      (:000
                        (\<lambda>ap.
                            :001
                             (:000
                               (\<lambda>aq.
                                   :001
                                    (:000
(\<lambda>ar.
    :001
     (:000
       (\<lambda>as.
           :001
            (:000
              (\<lambda>at.
                  :001
                   (:000
                     (\<lambda>au.
                         :001
                          (:000
                            (\<lambda>av.
                                :001
                                 (:000
                                   (\<lambda>aw.
 :001
  (:000
    (\<lambda>ax.
        :001
         (:000
           (?T53 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab
             ac ad ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw
             ax))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
Enter MATCH
\<lambda>x a b c d e f g h i j k l m n o p q r s t u v w y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba bb bc
   bd be bf bg bh bi.
   :001
    (:000
      (?\<V>64 a b c d e f g h i j k l m n o p q r s t u v w y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba
        bb bc bd be bf bg bh bi)) \<equiv>\<^sup>?
\<lambda>x.
   ?\<V>64
    (:000
      (\<lambda>a.
          :001
           (:000
             (\<lambda>b.
                 :001
                  (:000
                    (\<lambda>c.
                        :001
                         (:000
                           (\<lambda>d.
                               :001
                                (:000
                                  (\<lambda>e.
:001
 (:000
   (\<lambda>f.
       :001
        (:000
          (\<lambda>g.
              :001
               (:000
                 (\<lambda>h.
                     :001
                      (:000
                        (\<lambda>i.
                            :001
                             (:000
                               (\<lambda>j.
                                   :001
                                    (:000
(\<lambda>k.
    :001
     (:000
       (\<lambda>l.
           :001
            (:000
              (\<lambda>m.
                  :001
                   (:000
                     (\<lambda>n.
                         :001
                          (:000
                            (\<lambda>o.
                                :001
                                 (:000
                                   (\<lambda>p.
 :001
  (:000
    (\<lambda>q.
        :001
         (:000
           (\<lambda>r.
               :001
                (:000
                  (\<lambda>s.
                      :001
                       (:000
                         (\<lambda>t.
                             :001
                              (:000
                                (\<lambda>u.
                                    :001
                                     (:000
 (\<lambda>v.
     :001
      (:000
        (\<lambda>w.
            :001
             (:000
               (\<lambda>x.
                   :001
                    (:000
                      (\<lambda>y.
                          :001
                           (:000
                             (\<lambda>z.
                                 :001
                                  (:000
                                    (\<lambda>aa.
  :001
   (:000
     (\<lambda>ab.
         :001
          (:000
            (\<lambda>ac.
                :001
                 (:000
                   (\<lambda>ad.
                       :001
                        (:000
                          (\<lambda>ae.
                              :001
                               (:000
                                 (\<lambda>af.
                                     :001
(:000
  (\<lambda>ag.
      :001
       (:000
         (\<lambda>ah.
             :001
              (:000
                (\<lambda>ai.
                    :001
                     (:000
                       (\<lambda>aj.
                           :001
                            (:000
                              (\<lambda>ak.
                                  :001
                                   (:000
                                     (\<lambda>al.
   :001
    (:000
      (\<lambda>am.
          :001
           (:000
             (\<lambda>an.
                 :001
                  (:000
                    (\<lambda>ao.
                        :001
                         (:000
                           (\<lambda>ap.
                               :001
                                (:000
                                  (\<lambda>aq.
:001
 (:000
   (\<lambda>ar.
       :001
        (:000
          (\<lambda>as.
              :001
               (:000
                 (\<lambda>at.
                     :001
                      (:000
                        (\<lambda>au.
                            :001
                             (:000
                               (\<lambda>av.
                                   :001
                                    (:000
(\<lambda>aw.
    :001
     (:000
       (\<lambda>ax.
           :001
            (:000
              (\<lambda>ay.
                  :001
                   (:000
                     (\<lambda>az.
                         :001
                          (:000
                            (\<lambda>ba.
                                :001
                                 (:000
                                   (\<lambda>bb.
 :001
  (:000
    (\<lambda>bc.
        :001
         (:000
           (\<lambda>bd.
               :001
                (:000
                  (\<lambda>be.
                      :001
                       (:000
                         (\<lambda>bf.
                             :001
                              (:000
                                (\<lambda>bg.
                                    :001
                                     (:000
 (\<lambda>bh.
     :001
      (:000
        (?\<V>64 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab
          ac ad ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax
          ay az ba bb bc bd be bf bg
          bh))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
### Unification bound exceeded
### Ignoring duplicate rewrite rule:
### of_nat (?m1 ^ ?n1) \<equiv> of_nat ?m1 ^ ?n1
\<lambda>a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay.
   :001
    (:000
      (?T54 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax
        ay)) \<equiv>\<^sup>?
?T54
 (:000
   (\<lambda>a.
       :001
        (:000
          (\<lambda>b.
              :001
               (:000
                 (\<lambda>c.
                     :001
                      (:000
                        (\<lambda>d.
                            :001
                             (:000
                               (\<lambda>e.
                                   :001
                                    (:000
(\<lambda>f.
    :001
     (:000
       (\<lambda>g.
           :001
            (:000
              (\<lambda>h.
                  :001
                   (:000
                     (\<lambda>i.
                         :001
                          (:000
                            (\<lambda>j.
                                :001
                                 (:000
                                   (\<lambda>k.
 :001
  (:000
    (\<lambda>l.
        :001
         (:000
           (\<lambda>m.
               :001
                (:000
                  (\<lambda>n.
                      :001
                       (:000
                         (\<lambda>o.
                             :001
                              (:000
                                (\<lambda>p.
                                    :001
                                     (:000
 (\<lambda>q.
     :001
      (:000
        (\<lambda>r.
            :001
             (:000
               (\<lambda>s.
                   :001
                    (:000
                      (\<lambda>t.
                          :001
                           (:000
                             (\<lambda>u.
                                 :001
                                  (:000
                                    (\<lambda>v.
  :001
   (:000
     (\<lambda>w.
         :001
          (:000
            (\<lambda>x.
                :001
                 (:000
                   (\<lambda>y.
                       :001
                        (:000
                          (\<lambda>z.
                              :001
                               (:000
                                 (\<lambda>aa.
                                     :001
(:000
  (\<lambda>ab.
      :001
       (:000
         (\<lambda>ac.
             :001
              (:000
                (\<lambda>ad.
                    :001
                     (:000
                       (\<lambda>ae.
                           :001
                            (:000
                              (\<lambda>af.
                                  :001
                                   (:000
                                     (\<lambda>ag.
   :001
    (:000
      (\<lambda>ah.
          :001
           (:000
             (\<lambda>ai.
                 :001
                  (:000
                    (\<lambda>aj.
                        :001
                         (:000
                           (\<lambda>ak.
                               :001
                                (:000
                                  (\<lambda>al.
:001
 (:000
   (\<lambda>am.
       :001
        (:000
          (\<lambda>an.
              :001
               (:000
                 (\<lambda>ao.
                     :001
                      (:000
                        (\<lambda>ap.
                            :001
                             (:000
                               (\<lambda>aq.
                                   :001
                                    (:000
(\<lambda>ar.
    :001
     (:000
       (\<lambda>as.
           :001
            (:000
              (\<lambda>at.
                  :001
                   (:000
                     (\<lambda>au.
                         :001
                          (:000
                            (\<lambda>av.
                                :001
                                 (:000
                                   (\<lambda>aw.
 :001
  (:000
    (\<lambda>ax.
        :001
         (:000
           (\<lambda>ay.
               :001
                (:000
                  (?T54 a b c d e f g h i j k l m n o p q r s t u v w x y z
                    aa ab ac ad ae af ag ah ai aj ak al am an ao ap aq ar as
                    at au av aw ax
                    ay))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
Enter MATCH
\<lambda>a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az.
   :001
    (:000
      (?T55 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay
        az)) \<equiv>\<^sup>?
?T55
 (:000
   (\<lambda>a.
       :001
        (:000
          (\<lambda>b.
              :001
               (:000
                 (\<lambda>c.
                     :001
                      (:000
                        (\<lambda>d.
                            :001
                             (:000
                               (\<lambda>e.
                                   :001
                                    (:000
(\<lambda>f.
    :001
     (:000
       (\<lambda>g.
           :001
            (:000
              (\<lambda>h.
                  :001
                   (:000
                     (\<lambda>i.
                         :001
                          (:000
                            (\<lambda>j.
                                :001
                                 (:000
                                   (\<lambda>k.
 :001
  (:000
    (\<lambda>l.
        :001
         (:000
           (\<lambda>m.
               :001
                (:000
                  (\<lambda>n.
                      :001
                       (:000
                         (\<lambda>o.
                             :001
                              (:000
                                (\<lambda>p.
                                    :001
                                     (:000
 (\<lambda>q.
     :001
      (:000
        (\<lambda>r.
            :001
             (:000
               (\<lambda>s.
                   :001
                    (:000
                      (\<lambda>t.
                          :001
                           (:000
                             (\<lambda>u.
                                 :001
                                  (:000
                                    (\<lambda>v.
  :001
   (:000
     (\<lambda>w.
         :001
          (:000
            (\<lambda>x.
                :001
                 (:000
                   (\<lambda>y.
                       :001
                        (:000
                          (\<lambda>z.
                              :001
                               (:000
                                 (\<lambda>aa.
                                     :001
(:000
  (\<lambda>ab.
      :001
       (:000
         (\<lambda>ac.
             :001
              (:000
                (\<lambda>ad.
                    :001
                     (:000
                       (\<lambda>ae.
                           :001
                            (:000
                              (\<lambda>af.
                                  :001
                                   (:000
                                     (\<lambda>ag.
   :001
    (:000
      (\<lambda>ah.
          :001
           (:000
             (\<lambda>ai.
                 :001
                  (:000
                    (\<lambda>aj.
                        :001
                         (:000
                           (\<lambda>ak.
                               :001
                                (:000
                                  (\<lambda>al.
:001
 (:000
   (\<lambda>am.
       :001
        (:000
          (\<lambda>an.
              :001
               (:000
                 (\<lambda>ao.
                     :001
                      (:000
                        (\<lambda>ap.
                            :001
                             (:000
                               (\<lambda>aq.
                                   :001
                                    (:000
(\<lambda>ar.
    :001
     (:000
       (\<lambda>as.
           :001
            (:000
              (\<lambda>at.
                  :001
                   (:000
                     (\<lambda>au.
                         :001
                          (:000
                            (\<lambda>av.
                                :001
                                 (:000
                                   (\<lambda>aw.
 :001
  (:000
    (\<lambda>ax.
        :001
         (:000
           (\<lambda>ay.
               :001
                (:000
                  (\<lambda>az.
                      :001
                       (:000
                         (?T55 a b c d e f g h i j k l m n o p q r s t u v w
                           x y z aa ab ac ad ae af ag ah ai aj ak al am an
                           ao ap aq ar as at au av aw ax ay
                           az))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
Enter MATCH
\<lambda>a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba.
   :001
    (:000
      (?T56 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az
        ba)) \<equiv>\<^sup>?
?T56
 (:000
   (\<lambda>a.
       :001
        (:000
          (\<lambda>b.
              :001
               (:000
                 (\<lambda>c.
                     :001
                      (:000
                        (\<lambda>d.
                            :001
                             (:000
                               (\<lambda>e.
                                   :001
                                    (:000
(\<lambda>f.
    :001
     (:000
       (\<lambda>g.
           :001
            (:000
              (\<lambda>h.
                  :001
                   (:000
                     (\<lambda>i.
                         :001
                          (:000
                            (\<lambda>j.
                                :001
                                 (:000
                                   (\<lambda>k.
 :001
  (:000
    (\<lambda>l.
        :001
         (:000
           (\<lambda>m.
               :001
                (:000
                  (\<lambda>n.
                      :001
                       (:000
                         (\<lambda>o.
                             :001
                              (:000
                                (\<lambda>p.
                                    :001
                                     (:000
 (\<lambda>q.
     :001
      (:000
        (\<lambda>r.
            :001
             (:000
               (\<lambda>s.
                   :001
                    (:000
                      (\<lambda>t.
                          :001
                           (:000
                             (\<lambda>u.
                                 :001
                                  (:000
                                    (\<lambda>v.
  :001
   (:000
     (\<lambda>w.
         :001
          (:000
            (\<lambda>x.
                :001
                 (:000
                   (\<lambda>y.
                       :001
                        (:000
                          (\<lambda>z.
                              :001
                               (:000
                                 (\<lambda>aa.
                                     :001
(:000
  (\<lambda>ab.
      :001
       (:000
         (\<lambda>ac.
             :001
              (:000
                (\<lambda>ad.
                    :001
                     (:000
                       (\<lambda>ae.
                           :001
                            (:000
                              (\<lambda>af.
                                  :001
                                   (:000
                                     (\<lambda>ag.
   :001
    (:000
      (\<lambda>ah.
          :001
           (:000
             (\<lambda>ai.
                 :001
                  (:000
                    (\<lambda>aj.
                        :001
                         (:000
                           (\<lambda>ak.
                               :001
                                (:000
                                  (\<lambda>al.
:001
 (:000
   (\<lambda>am.
       :001
        (:000
          (\<lambda>an.
              :001
               (:000
                 (\<lambda>ao.
                     :001
                      (:000
                        (\<lambda>ap.
                            :001
                             (:000
                               (\<lambda>aq.
                                   :001
                                    (:000
(\<lambda>ar.
    :001
     (:000
       (\<lambda>as.
           :001
            (:000
              (\<lambda>at.
                  :001
                   (:000
                     (\<lambda>au.
                         :001
                          (:000
                            (\<lambda>av.
                                :001
                                 (:000
                                   (\<lambda>aw.
 :001
  (:000
    (\<lambda>ax.
        :001
         (:000
           (\<lambda>ay.
               :001
                (:000
                  (\<lambda>az.
                      :001
                       (:000
                         (\<lambda>ba.
                             :001
                              (:000
                                (?T56 a b c d e f g h i j k l m n o p q r s
                                  t u v w x y z aa ab ac ad ae af ag ah ai
                                  aj ak al am an ao ap aq ar as at au av aw
                                  ax ay az
                                  ba))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
Enter MATCH
\<lambda>a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba bb.
   :001
    (:000
      (?T57 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba
        bb)) \<equiv>\<^sup>?
?T57
 (:000
   (\<lambda>a.
       :001
        (:000
          (\<lambda>b.
              :001
               (:000
                 (\<lambda>c.
                     :001
                      (:000
                        (\<lambda>d.
                            :001
                             (:000
                               (\<lambda>e.
                                   :001
                                    (:000
(\<lambda>f.
    :001
     (:000
       (\<lambda>g.
           :001
            (:000
              (\<lambda>h.
                  :001
                   (:000
                     (\<lambda>i.
                         :001
                          (:000
                            (\<lambda>j.
                                :001
                                 (:000
                                   (\<lambda>k.
 :001
  (:000
    (\<lambda>l.
        :001
         (:000
           (\<lambda>m.
               :001
                (:000
                  (\<lambda>n.
                      :001
                       (:000
                         (\<lambda>o.
                             :001
                              (:000
                                (\<lambda>p.
                                    :001
                                     (:000
 (\<lambda>q.
     :001
      (:000
        (\<lambda>r.
            :001
             (:000
               (\<lambda>s.
                   :001
                    (:000
                      (\<lambda>t.
                          :001
                           (:000
                             (\<lambda>u.
                                 :001
                                  (:000
                                    (\<lambda>v.
  :001
   (:000
     (\<lambda>w.
         :001
          (:000
            (\<lambda>x.
                :001
                 (:000
                   (\<lambda>y.
                       :001
                        (:000
                          (\<lambda>z.
                              :001
                               (:000
                                 (\<lambda>aa.
                                     :001
(:000
  (\<lambda>ab.
      :001
       (:000
         (\<lambda>ac.
             :001
              (:000
                (\<lambda>ad.
                    :001
                     (:000
                       (\<lambda>ae.
                           :001
                            (:000
                              (\<lambda>af.
                                  :001
                                   (:000
                                     (\<lambda>ag.
   :001
    (:000
      (\<lambda>ah.
          :001
           (:000
             (\<lambda>ai.
                 :001
                  (:000
                    (\<lambda>aj.
                        :001
                         (:000
                           (\<lambda>ak.
                               :001
                                (:000
                                  (\<lambda>al.
:001
 (:000
   (\<lambda>am.
       :001
        (:000
          (\<lambda>an.
              :001
               (:000
                 (\<lambda>ao.
                     :001
                      (:000
                        (\<lambda>ap.
                            :001
                             (:000
                               (\<lambda>aq.
                                   :001
                                    (:000
(\<lambda>ar.
    :001
     (:000
       (\<lambda>as.
           :001
            (:000
              (\<lambda>at.
                  :001
                   (:000
                     (\<lambda>au.
                         :001
                          (:000
                            (\<lambda>av.
                                :001
                                 (:000
                                   (\<lambda>aw.
 :001
  (:000
    (\<lambda>ax.
        :001
         (:000
           (\<lambda>ay.
               :001
                (:000
                  (\<lambda>az.
                      :001
                       (:000
                         (\<lambda>ba.
                             :001
                              (:000
                                (\<lambda>bb.
                                    :001
                                     (:000
 (?T57 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae af
   ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba
   bb))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
Enter MATCH
\<lambda>a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba bb bc.
   :001
    (:000
      (?T58 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba
        bb bc)) \<equiv>\<^sup>?
?T58
 (:000
   (\<lambda>a.
       :001
        (:000
          (\<lambda>b.
              :001
               (:000
                 (\<lambda>c.
                     :001
                      (:000
                        (\<lambda>d.
                            :001
                             (:000
                               (\<lambda>e.
                                   :001
                                    (:000
(\<lambda>f.
    :001
     (:000
       (\<lambda>g.
           :001
            (:000
              (\<lambda>h.
                  :001
                   (:000
                     (\<lambda>i.
                         :001
                          (:000
                            (\<lambda>j.
                                :001
                                 (:000
                                   (\<lambda>k.
 :001
  (:000
    (\<lambda>l.
        :001
         (:000
           (\<lambda>m.
               :001
                (:000
                  (\<lambda>n.
                      :001
                       (:000
                         (\<lambda>o.
                             :001
                              (:000
                                (\<lambda>p.
                                    :001
                                     (:000
 (\<lambda>q.
     :001
      (:000
        (\<lambda>r.
            :001
             (:000
               (\<lambda>s.
                   :001
                    (:000
                      (\<lambda>t.
                          :001
                           (:000
                             (\<lambda>u.
                                 :001
                                  (:000
                                    (\<lambda>v.
  :001
   (:000
     (\<lambda>w.
         :001
          (:000
            (\<lambda>x.
                :001
                 (:000
                   (\<lambda>y.
                       :001
                        (:000
                          (\<lambda>z.
                              :001
                               (:000
                                 (\<lambda>aa.
                                     :001
(:000
  (\<lambda>ab.
      :001
       (:000
         (\<lambda>ac.
             :001
              (:000
                (\<lambda>ad.
                    :001
                     (:000
                       (\<lambda>ae.
                           :001
                            (:000
                              (\<lambda>af.
                                  :001
                                   (:000
                                     (\<lambda>ag.
   :001
    (:000
      (\<lambda>ah.
          :001
           (:000
             (\<lambda>ai.
                 :001
                  (:000
                    (\<lambda>aj.
                        :001
                         (:000
                           (\<lambda>ak.
                               :001
                                (:000
                                  (\<lambda>al.
:001
 (:000
   (\<lambda>am.
       :001
        (:000
          (\<lambda>an.
              :001
               (:000
                 (\<lambda>ao.
                     :001
                      (:000
                        (\<lambda>ap.
                            :001
                             (:000
                               (\<lambda>aq.
                                   :001
                                    (:000
(\<lambda>ar.
    :001
     (:000
       (\<lambda>as.
           :001
            (:000
              (\<lambda>at.
                  :001
                   (:000
                     (\<lambda>au.
                         :001
                          (:000
                            (\<lambda>av.
                                :001
                                 (:000
                                   (\<lambda>aw.
 :001
  (:000
    (\<lambda>ax.
        :001
         (:000
           (\<lambda>ay.
               :001
                (:000
                  (\<lambda>az.
                      :001
                       (:000
                         (\<lambda>ba.
                             :001
                              (:000
                                (\<lambda>bb.
                                    :001
                                     (:000
 (\<lambda>bc.
     :001
      (:000
        (?T58 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac
          ad ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay
          az ba bb
          bc))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
Enter MATCH
\<lambda>a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba bb bc
   bd.
   :001
    (:000
      (?T59 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba
        bb bc bd)) \<equiv>\<^sup>?
?T59
 (:000
   (\<lambda>a.
       :001
        (:000
          (\<lambda>b.
              :001
               (:000
                 (\<lambda>c.
                     :001
                      (:000
                        (\<lambda>d.
                            :001
                             (:000
                               (\<lambda>e.
                                   :001
                                    (:000
(\<lambda>f.
    :001
     (:000
       (\<lambda>g.
           :001
            (:000
              (\<lambda>h.
                  :001
                   (:000
                     (\<lambda>i.
                         :001
                          (:000
                            (\<lambda>j.
                                :001
                                 (:000
                                   (\<lambda>k.
 :001
  (:000
    (\<lambda>l.
        :001
         (:000
           (\<lambda>m.
               :001
                (:000
                  (\<lambda>n.
                      :001
                       (:000
                         (\<lambda>o.
                             :001
                              (:000
                                (\<lambda>p.
                                    :001
                                     (:000
 (\<lambda>q.
     :001
      (:000
        (\<lambda>r.
            :001
             (:000
               (\<lambda>s.
                   :001
                    (:000
                      (\<lambda>t.
                          :001
                           (:000
                             (\<lambda>u.
                                 :001
                                  (:000
                                    (\<lambda>v.
  :001
   (:000
     (\<lambda>w.
         :001
          (:000
            (\<lambda>x.
                :001
                 (:000
                   (\<lambda>y.
                       :001
                        (:000
                          (\<lambda>z.
                              :001
                               (:000
                                 (\<lambda>aa.
                                     :001
(:000
  (\<lambda>ab.
      :001
       (:000
         (\<lambda>ac.
             :001
              (:000
                (\<lambda>ad.
                    :001
                     (:000
                       (\<lambda>ae.
                           :001
                            (:000
                              (\<lambda>af.
                                  :001
                                   (:000
                                     (\<lambda>ag.
   :001
    (:000
      (\<lambda>ah.
          :001
           (:000
             (\<lambda>ai.
                 :001
                  (:000
                    (\<lambda>aj.
                        :001
                         (:000
                           (\<lambda>ak.
                               :001
                                (:000
                                  (\<lambda>al.
:001
 (:000
   (\<lambda>am.
       :001
        (:000
          (\<lambda>an.
              :001
               (:000
                 (\<lambda>ao.
                     :001
                      (:000
                        (\<lambda>ap.
                            :001
                             (:000
                               (\<lambda>aq.
                                   :001
                                    (:000
(\<lambda>ar.
    :001
     (:000
       (\<lambda>as.
           :001
            (:000
              (\<lambda>at.
                  :001
                   (:000
                     (\<lambda>au.
                         :001
                          (:000
                            (\<lambda>av.
                                :001
                                 (:000
                                   (\<lambda>aw.
 :001
  (:000
    (\<lambda>ax.
        :001
         (:000
           (\<lambda>ay.
               :001
                (:000
                  (\<lambda>az.
                      :001
                       (:000
                         (\<lambda>ba.
                             :001
                              (:000
                                (\<lambda>bb.
                                    :001
                                     (:000
 (\<lambda>bc.
     :001
      (:000
        (\<lambda>bd.
            :001
             (:000
               (?T59 a b c d e f g h i j k l m n o p q r s t u v w x y z aa
                 ab ac ad ae af ag ah ai aj ak al am an ao ap aq ar as at au
                 av aw ax ay az ba bb bc
                 bd))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
Enter MATCH
\<lambda>a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba bb bc
   bd be.
   :001
    (:000
      (?T60 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba
        bb bc bd be)) \<equiv>\<^sup>?
?T60
 (:000
   (\<lambda>a.
       :001
        (:000
          (\<lambda>b.
              :001
               (:000
                 (\<lambda>c.
                     :001
                      (:000
                        (\<lambda>d.
                            :001
                             (:000
                               (\<lambda>e.
                                   :001
                                    (:000
(\<lambda>f.
    :001
     (:000
       (\<lambda>g.
           :001
            (:000
              (\<lambda>h.
                  :001
                   (:000
                     (\<lambda>i.
                         :001
                          (:000
                            (\<lambda>j.
                                :001
                                 (:000
                                   (\<lambda>k.
 :001
  (:000
    (\<lambda>l.
        :001
         (:000
           (\<lambda>m.
               :001
                (:000
                  (\<lambda>n.
                      :001
                       (:000
                         (\<lambda>o.
                             :001
                              (:000
                                (\<lambda>p.
                                    :001
                                     (:000
 (\<lambda>q.
     :001
      (:000
        (\<lambda>r.
            :001
             (:000
               (\<lambda>s.
                   :001
                    (:000
                      (\<lambda>t.
                          :001
                           (:000
                             (\<lambda>u.
                                 :001
                                  (:000
                                    (\<lambda>v.
  :001
   (:000
     (\<lambda>w.
         :001
          (:000
            (\<lambda>x.
                :001
                 (:000
                   (\<lambda>y.
                       :001
                        (:000
                          (\<lambda>z.
                              :001
                               (:000
                                 (\<lambda>aa.
                                     :001
(:000
  (\<lambda>ab.
      :001
       (:000
         (\<lambda>ac.
             :001
              (:000
                (\<lambda>ad.
                    :001
                     (:000
                       (\<lambda>ae.
                           :001
                            (:000
                              (\<lambda>af.
                                  :001
                                   (:000
                                     (\<lambda>ag.
   :001
    (:000
      (\<lambda>ah.
          :001
           (:000
             (\<lambda>ai.
                 :001
                  (:000
                    (\<lambda>aj.
                        :001
                         (:000
                           (\<lambda>ak.
                               :001
                                (:000
                                  (\<lambda>al.
:001
 (:000
   (\<lambda>am.
       :001
        (:000
          (\<lambda>an.
              :001
               (:000
                 (\<lambda>ao.
                     :001
                      (:000
                        (\<lambda>ap.
                            :001
                             (:000
                               (\<lambda>aq.
                                   :001
                                    (:000
(\<lambda>ar.
    :001
     (:000
       (\<lambda>as.
           :001
            (:000
              (\<lambda>at.
                  :001
                   (:000
                     (\<lambda>au.
                         :001
                          (:000
                            (\<lambda>av.
                                :001
                                 (:000
                                   (\<lambda>aw.
 :001
  (:000
    (\<lambda>ax.
        :001
         (:000
           (\<lambda>ay.
               :001
                (:000
                  (\<lambda>az.
                      :001
                       (:000
                         (\<lambda>ba.
                             :001
                              (:000
                                (\<lambda>bb.
                                    :001
                                     (:000
 (\<lambda>bc.
     :001
      (:000
        (\<lambda>bd.
            :001
             (:000
               (\<lambda>be.
                   :001
                    (:000
                      (?T60 a b c d e f g h i j k l m n o p q r s t u v w x
                        y z aa ab ac ad ae af ag ah ai aj ak al am an ao ap
                        aq ar as at au av aw ax ay az ba bb bc bd
                        be))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
Enter MATCH
\<lambda>a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba bb bc
   bd be bf.
   :001
    (:000
      (?T61 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba
        bb bc bd be bf)) \<equiv>\<^sup>?
?T61
 (:000
   (\<lambda>a.
       :001
        (:000
          (\<lambda>b.
              :001
               (:000
                 (\<lambda>c.
                     :001
                      (:000
                        (\<lambda>d.
                            :001
                             (:000
                               (\<lambda>e.
                                   :001
                                    (:000
(\<lambda>f.
    :001
     (:000
       (\<lambda>g.
           :001
            (:000
              (\<lambda>h.
                  :001
                   (:000
                     (\<lambda>i.
                         :001
                          (:000
                            (\<lambda>j.
                                :001
                                 (:000
                                   (\<lambda>k.
 :001
  (:000
    (\<lambda>l.
        :001
         (:000
           (\<lambda>m.
               :001
                (:000
                  (\<lambda>n.
                      :001
                       (:000
                         (\<lambda>o.
                             :001
                              (:000
                                (\<lambda>p.
                                    :001
                                     (:000
 (\<lambda>q.
     :001
      (:000
        (\<lambda>r.
            :001
             (:000
               (\<lambda>s.
                   :001
                    (:000
                      (\<lambda>t.
                          :001
                           (:000
                             (\<lambda>u.
                                 :001
                                  (:000
                                    (\<lambda>v.
  :001
   (:000
     (\<lambda>w.
         :001
          (:000
            (\<lambda>x.
                :001
                 (:000
                   (\<lambda>y.
                       :001
                        (:000
                          (\<lambda>z.
                              :001
                               (:000
                                 (\<lambda>aa.
                                     :001
(:000
  (\<lambda>ab.
      :001
       (:000
         (\<lambda>ac.
             :001
              (:000
                (\<lambda>ad.
                    :001
                     (:000
                       (\<lambda>ae.
                           :001
                            (:000
                              (\<lambda>af.
                                  :001
                                   (:000
                                     (\<lambda>ag.
   :001
    (:000
      (\<lambda>ah.
          :001
           (:000
             (\<lambda>ai.
                 :001
                  (:000
                    (\<lambda>aj.
                        :001
                         (:000
                           (\<lambda>ak.
                               :001
                                (:000
                                  (\<lambda>al.
:001
 (:000
   (\<lambda>am.
       :001
        (:000
          (\<lambda>an.
              :001
               (:000
                 (\<lambda>ao.
                     :001
                      (:000
                        (\<lambda>ap.
                            :001
                             (:000
                               (\<lambda>aq.
                                   :001
                                    (:000
(\<lambda>ar.
    :001
     (:000
       (\<lambda>as.
           :001
            (:000
              (\<lambda>at.
                  :001
                   (:000
                     (\<lambda>au.
                         :001
                          (:000
                            (\<lambda>av.
                                :001
                                 (:000
                                   (\<lambda>aw.
 :001
  (:000
    (\<lambda>ax.
        :001
         (:000
           (\<lambda>ay.
               :001
                (:000
                  (\<lambda>az.
                      :001
                       (:000
                         (\<lambda>ba.
                             :001
                              (:000
                                (\<lambda>bb.
                                    :001
                                     (:000
 (\<lambda>bc.
     :001
      (:000
        (\<lambda>bd.
            :001
             (:000
               (\<lambda>be.
                   :001
                    (:000
                      (\<lambda>bf.
                          :001
                           (:000
                             (?T61 a b c d e f g h i j k l m n o p q r s t u
                               v w x y z aa ab ac ad ae af ag ah ai aj ak al
                               am an ao ap aq ar as at au av aw ax ay az ba
                               bb bc bd be
                               bf))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
Enter MATCH
\<lambda>a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae
   af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba bb bc
   bd be bf bg.
   :001
    (:000
      (?T62 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad
        ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az ba
        bb bc bd be bf bg)) \<equiv>\<^sup>?
?T62
 (:000
   (\<lambda>a.
       :001
        (:000
          (\<lambda>b.
              :001
               (:000
                 (\<lambda>c.
                     :001
                      (:000
                        (\<lambda>d.
                            :001
                             (:000
                               (\<lambda>e.
                                   :001
                                    (:000
(\<lambda>f.
    :001
     (:000
       (\<lambda>g.
           :001
            (:000
              (\<lambda>h.
                  :001
                   (:000
                     (\<lambda>i.
                         :001
                          (:000
                            (\<lambda>j.
                                :001
                                 (:000
                                   (\<lambda>k.
 :001
  (:000
    (\<lambda>l.
        :001
         (:000
           (\<lambda>m.
               :001
                (:000
                  (\<lambda>n.
                      :001
                       (:000
                         (\<lambda>o.
                             :001
                              (:000
                                (\<lambda>p.
                                    :001
                                     (:000
 (\<lambda>q.
     :001
      (:000
        (\<lambda>r.
            :001
             (:000
               (\<lambda>s.
                   :001
                    (:000
                      (\<lambda>t.
                          :001
                           (:000
                             (\<lambda>u.
                                 :001
                                  (:000
                                    (\<lambda>v.
  :001
   (:000
     (\<lambda>w.
         :001
          (:000
            (\<lambda>x.
                :001
                 (:000
                   (\<lambda>y.
                       :001
                        (:000
                          (\<lambda>z.
                              :001
                               (:000
                                 (\<lambda>aa.
                                     :001
(:000
  (\<lambda>ab.
      :001
       (:000
         (\<lambda>ac.
             :001
              (:000
                (\<lambda>ad.
                    :001
                     (:000
                       (\<lambda>ae.
                           :001
                            (:000
                              (\<lambda>af.
                                  :001
                                   (:000
                                     (\<lambda>ag.
   :001
    (:000
      (\<lambda>ah.
          :001
           (:000
             (\<lambda>ai.
                 :001
                  (:000
                    (\<lambda>aj.
                        :001
                         (:000
                           (\<lambda>ak.
                               :001
                                (:000
                                  (\<lambda>al.
:001
 (:000
   (\<lambda>am.
       :001
        (:000
          (\<lambda>an.
              :001
               (:000
                 (\<lambda>ao.
                     :001
                      (:000
                        (\<lambda>ap.
                            :001
                             (:000
                               (\<lambda>aq.
                                   :001
                                    (:000
(\<lambda>ar.
    :001
     (:000
       (\<lambda>as.
           :001
            (:000
              (\<lambda>at.
                  :001
                   (:000
                     (\<lambda>au.
                         :001
                          (:000
                            (\<lambda>av.
                                :001
                                 (:000
                                   (\<lambda>aw.
 :001
  (:000
    (\<lambda>ax.
        :001
         (:000
           (\<lambda>ay.
               :001
                (:000
                  (\<lambda>az.
                      :001
                       (:000
                         (\<lambda>ba.
                             :001
                              (:000
                                (\<lambda>bb.
                                    :001
                                     (:000
 (\<lambda>bc.
     :001
      (:000
        (\<lambda>bd.
            :001
             (:000
               (\<lambda>be.
                   :001
                    (:000
                      (\<lambda>bf.
                          :001
                           (:000
                             (\<lambda>bg.
                                 :001
                                  (:000
                                    (?T62 a b c d e f g h i j k l m n o p q
r s t u v w x y z aa ab ac ad ae af ag ah ai aj ak al am an ao ap aq ar as
at au av aw ax ay az ba bb bc bd be bf
bg))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Failure node
### Unification bound exceeded
### Rule already declared as introduction (intro)
### \<lbrakk>?a \<in> M; ?b \<in> M\<rbrakk> \<Longrightarrow> ?a - ?b \<in> M
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### 0 < DIM(?'a1) \<equiv> True
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### \<lbrakk>finite ?A1; ?A1 \<noteq> {}\<rbrakk>
### \<Longrightarrow> ?x1 < Min ?A1 \<equiv> \<forall>a\<in>?A1. ?x1 < a
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### aff_dim UNIV \<equiv> int DIM(?'n1)
### Ignoring duplicate rewrite rule:
### enn2ereal top \<equiv> \<infinity>
### Rule already declared as safe introduction (intro!)
### uniform_limit {} ?f ?g ?F
### Ignoring duplicate rewrite rule:
### rel_interior {} \<equiv> {}
### Ignoring duplicate rewrite rule:
### rel_interior {} \<equiv> {}
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate introduction (intro)
### open {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### closed {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### closed UNIV
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Ignoring duplicate introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Ignoring duplicate introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### affine hull (convex hull ?S1) \<equiv> affine hull ?S1
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Ignoring duplicate rewrite rule:
### 0 < DIM(?'a1) \<equiv> True
### Ignoring duplicate rewrite rule:
### ?x1 = (?u1 / ?v1) *\<^sub>R ?a1 \<equiv>
### if ?v1 = 0 then ?x1 = (0::?'a1) else ?v1 *\<^sub>R ?x1 = ?u1 *\<^sub>R ?a1
### Rewrite rule not in simpset:
### numeral ?w1 \<le> ?b1 / ?c1 \<equiv>
### if (0::?'a1) < ?c1 then numeral ?w1 * ?c1 \<le> ?b1
### else if ?c1 < (0::?'a1) then ?b1 \<le> numeral ?w1 * ?c1
###      else numeral ?w1 \<le> (0::?'a1)
### Rewrite rule not in simpset:
### - numeral ?w1 \<le> ?b1 / ?c1 \<equiv>
### if (0::?'a1) < ?c1 then - numeral ?w1 * ?c1 \<le> ?b1
### else if ?c1 < (0::?'a1) then ?b1 \<le> - numeral ?w1 * ?c1
###      else - numeral ?w1 \<le> (0::?'a1)
### Rewrite rule not in simpset:
### ?b1 / ?c1 \<le> numeral ?w1 \<equiv>
### if (0::?'a1) < ?c1 then ?b1 \<le> numeral ?w1 * ?c1
### else if ?c1 < (0::?'a1) then numeral ?w1 * ?c1 \<le> ?b1
###      else (0::?'a1) \<le> numeral ?w1
### Rewrite rule not in simpset:
### ?b1 / ?c1 \<le> - numeral ?w1 \<equiv>
### if (0::?'a1) < ?c1 then ?b1 \<le> - numeral ?w1 * ?c1
### else if ?c1 < (0::?'a1) then - numeral ?w1 * ?c1 \<le> ?b1
###      else (0::?'a1) \<le> - numeral ?w1
### Rewrite rule not in simpset:
### numeral ?w1 < ?b1 / ?c1 \<equiv>
### if (0::?'a1) < ?c1 then numeral ?w1 * ?c1 < ?b1
### else if ?c1 < (0::?'a1) then ?b1 < numeral ?w1 * ?c1
###      else numeral ?w1 < (0::?'a1)
### Rewrite rule not in simpset:
### - numeral ?w1 < ?b1 / ?c1 \<equiv>
### if (0::?'a1) < ?c1 then - numeral ?w1 * ?c1 < ?b1
### else if ?c1 < (0::?'a1) then ?b1 < - numeral ?w1 * ?c1
###      else - numeral ?w1 < (0::?'a1)
### Rewrite rule not in simpset:
### ?b1 / ?c1 < numeral ?w1 \<equiv>
### if (0::?'a1) < ?c1 then ?b1 < numeral ?w1 * ?c1
### else if ?c1 < (0::?'a1) then numeral ?w1 * ?c1 < ?b1
###      else (0::?'a1) < numeral ?w1
### Rewrite rule not in simpset:
### ?b1 / ?c1 < - numeral ?w1 \<equiv>
### if (0::?'a1) < ?c1 then ?b1 < - numeral ?w1 * ?c1
### else if ?c1 < (0::?'a1) then - numeral ?w1 * ?c1 < ?b1
###      else (0::?'a1) < - numeral ?w1
### Rewrite rule not in simpset:
### numeral ?w1 = ?b1 / ?c1 \<equiv>
### if ?c1 \<noteq> (0::?'a1) then numeral ?w1 * ?c1 = ?b1
### else numeral ?w1 = (0::?'a1)
### Rewrite rule not in simpset:
### - numeral ?w1 = ?b1 / ?c1 \<equiv>
### if ?c1 \<noteq> (0::?'a1) then - numeral ?w1 * ?c1 = ?b1
### else - numeral ?w1 = (0::?'a1)
### Rewrite rule not in simpset:
### ?b1 / ?c1 = numeral ?w1 \<equiv>
### if ?c1 \<noteq> (0::?'a1) then ?b1 = numeral ?w1 * ?c1
### else numeral ?w1 = (0::?'a1)
### Rewrite rule not in simpset:
### ?b1 / ?c1 = - numeral ?w1 \<equiv>
### if ?c1 \<noteq> (0::?'a1) then ?b1 = - numeral ?w1 * ?c1
### else - numeral ?w1 = (0::?'a1)
### Rewrite rule not in simpset:
### (1::?'a1) \<le> ?b1 / ?a1 \<equiv>
### (0::?'a1) < ?a1 \<and> ?a1 \<le> ?b1 \<or>
### ?a1 < (0::?'a1) \<and> ?b1 \<le> ?a1
### Rewrite rule not in simpset:
### ?b1 / ?a1 \<le> (1::?'a1) \<equiv>
### (0::?'a1) < ?a1 \<and> ?b1 \<le> ?a1 \<or>
### ?a1 < (0::?'a1) \<and> ?a1 \<le> ?b1 \<or> ?a1 = (0::?'a1)
### Rewrite rule not in simpset:
### (1::?'a1) < ?b1 / ?a1 \<equiv>
### (0::?'a1) < ?a1 \<and> ?a1 < ?b1 \<or> ?a1 < (0::?'a1) \<and> ?b1 < ?a1
### Rewrite rule not in simpset:
### ?b1 / ?a1 < (1::?'a1) \<equiv>
### (0::?'a1) < ?a1 \<and> ?b1 < ?a1 \<or>
### ?a1 < (0::?'a1) \<and> ?a1 < ?b1 \<or> ?a1 = (0::?'a1)
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### aff_dim UNIV \<equiv> int DIM(?'n1)
### Ignoring duplicate rewrite rule:
### aff_dim (affine hull ?S1) \<equiv> aff_dim ?S1
### Ignoring duplicate rewrite rule:
### ?a1 \<noteq> (0::?'a1) \<Longrightarrow>
### aff_dim {x. ?a1 \<bullet> x = ?r1} \<equiv> int (DIM(?'a1) - 1)
### Ignoring duplicate rewrite rule:
### ?a1 \<noteq> (0::?'a1) \<Longrightarrow>
### aff_dim {x. ?a1 \<bullet> x = ?r1} \<equiv> int (DIM(?'a1) - 1)
### Ignoring duplicate rewrite rule:
### affine_dependent {?a1, ?b1} \<equiv> False
### Ignoring duplicate rewrite rule:
### aff_dim UNIV \<equiv> int DIM(?'n1)
### Metis: Unused theorems: "local.sumSS'_2"
### Ignoring duplicate rewrite rule:
### dim (span ?S1) \<equiv> dim ?S1
### Metis: Unused theorems: "local.sumSS'_1"
### Rule already declared as introduction (intro)
### \<lbrakk>?b = ?f ?x; ?x \<in> ?A\<rbrakk> \<Longrightarrow> ?b \<in> ?f ` ?A
### Metis: Unused theorems: "local.yl"
### Metis: Unused theorems: "local.xl"
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### 0 \<le> setdist ?s1 ?t1 \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Rule already declared as introduction (intro)
### ?A ` ?X \<subseteq> M \<Longrightarrow> \<Union> (?A ` ?X) \<in> M
### Metis: Unused theorems: "Line_Segment.midpoint_eq_endpoint_2"
### Ignoring duplicate rewrite rule:
### finite ?S1 \<Longrightarrow>
### \<Sum>k\<in>?S1. if k = ?a1 then ?b1 k else (0::?'a1) \<equiv>
### if ?a1 \<in> ?S1 then ?b1 ?a1 else (0::?'a1)
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Ignoring duplicate rewrite rule:
### finite ?S1 \<Longrightarrow>
### \<Sum>k\<in>?S1. if k = ?a1 then ?b1 k else (0::?'a1) \<equiv>
### if ?a1 \<in> ?S1 then ?b1 ?a1 else (0::?'a1)
### Ignoring duplicate introduction (intro)
### open {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### closed {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### closed UNIV
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Ignoring duplicate introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Ignoring duplicate introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>?a \<in> generated_ring; ?b \<in> generated_ring\<rbrakk>
### \<Longrightarrow> ?a \<inter> ?b \<in> generated_ring
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?X; ?X \<subseteq> generated_ring\<rbrakk>
### \<Longrightarrow> \<Union> ?X \<in> generated_ring
### Ignoring duplicate rewrite rule:
### finite ?S1 \<Longrightarrow>
### \<Sum>k\<in>?S1. if k = ?a1 then ?b1 k else (0::?'a1) \<equiv>
### if ?a1 \<in> ?S1 then ?b1 ?a1 else (0::?'a1)
### Ignoring duplicate introduction (intro)
### open {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### closed {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### closed UNIV
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Ignoring duplicate introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Ignoring duplicate introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### (\<And>x. ?f x = ?g x) \<Longrightarrow> ?f = ?g
### Ignoring duplicate rewrite rule:
### blinfun_apply 0 ?b1 \<equiv> 0::?'b1
### Ignoring duplicate rewrite rule:
### blinfun_apply ?a1 (0::?'a1) \<equiv> 0::?'b1
### Ignoring duplicate rewrite rule:
### blinfun_apply 0 ?b1 \<equiv> 0::?'b1
### Ignoring duplicate rewrite rule:
### blinfun_apply ?a1 (0::?'a1) \<equiv> 0::?'b1
### Ignoring duplicate rewrite rule:
### blinfun_apply 0 ?b1 \<equiv> 0::?'b1
### Ignoring duplicate rewrite rule:
### blinfun_apply ?a1 (0::?'a1) \<equiv> 0::?'b1
### Ignoring duplicate rewrite rule:
### blinfun_apply 0 ?b1 \<equiv> 0::?'b1
### Ignoring duplicate rewrite rule:
### blinfun_apply ?a1 (0::?'a1) \<equiv> 0::?'b1
### Rule already declared as introduction (intro)
### (\<And>x. ?f x = ?g x) \<Longrightarrow> ?f = ?g
### Ignoring duplicate rewrite rule:
### finite ?S1 \<Longrightarrow>
### \<Sum>k\<in>?S1. if k = ?a1 then ?b1 k else (0::?'a1) \<equiv>
### if ?a1 \<in> ?S1 then ?b1 ?a1 else (0::?'a1)
### Rule already declared as introduction (intro)
### \<lbrakk>?a \<in> generated_ring; ?b \<in> generated_ring\<rbrakk>
### \<Longrightarrow> ?a \<inter> ?b \<in> generated_ring
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?X; ?X \<subseteq> generated_ring\<rbrakk>
### \<Longrightarrow> \<Union> ?X \<in> generated_ring
### Rule already declared as introduction (intro)
### (\<And>x. ?f x = ?g x) \<Longrightarrow> ?f = ?g
### Ignoring duplicate introduction (intro)
### open {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### closed {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### closed UNIV
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Ignoring duplicate introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Ignoring duplicate introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Ignoring duplicate rewrite rule:
### blinfun_apply 0 ?b1 \<equiv> 0::?'b1
### Ignoring duplicate rewrite rule:
### blinfun_apply ?a1 (0::?'a1) \<equiv> 0::?'b1
### Rule already declared as introduction (intro)
### ((\<lambda>x. x) \<longlongrightarrow> ?a) (at ?a within ?s)
### Rule already declared as introduction (intro)
### ((\<lambda>x. ?k) \<longlongrightarrow> ?k) ?F
### Rule already declared as introduction (intro)
### (?f \<longlongrightarrow> ?x) ?F \<Longrightarrow>
### ((\<lambda>x. ereal (?f x)) \<longlongrightarrow> ereal ?x) ?F
### Rule already declared as introduction (intro)
### (?f \<longlongrightarrow> ?x) ?F \<Longrightarrow>
### ((\<lambda>x. - ?f x) \<longlongrightarrow> - ?x) ?F
### Rule already declared as introduction (intro)
### \<lbrakk>\<bar>?c\<bar> \<noteq> \<infinity>;
###  (?f \<longlongrightarrow> ?x) ?F\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?c * ?f x) \<longlongrightarrow> ?c * ?x) ?F
### Rule already declared as introduction (intro)
### \<lbrakk>?x \<noteq> 0; (?f \<longlongrightarrow> ?x) ?F\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?c * ?f x) \<longlongrightarrow> ?c * ?x) ?F
### Rule already declared as introduction (intro)
### \<lbrakk>?y \<noteq> - \<infinity>; ?x \<noteq> - \<infinity>;
###  (?f \<longlongrightarrow> ?x) ?F\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?f x + ?y) \<longlongrightarrow> ?x + ?y) ?F
### Rule already declared as introduction (intro)
### \<lbrakk>\<bar>?y\<bar> \<noteq> \<infinity>;
###  (?f \<longlongrightarrow> ?x) ?F\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?f x + ?y) \<longlongrightarrow> ?x + ?y) ?F
### Rule already declared as introduction (intro)
### (?f \<longlongrightarrow> ?x) ?F \<Longrightarrow>
### ((\<lambda>x. ennreal (?f x)) \<longlongrightarrow> ennreal ?x) ?F
### Ignoring duplicate rewrite rule:
### blinfun_apply 0 ?b1 \<equiv> 0::?'b1
### Ignoring duplicate rewrite rule:
### blinfun_apply ?a1 (0::?'a1) \<equiv> 0::?'b1
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Ignoring duplicate rewrite rule:
### finite ?S1 \<Longrightarrow>
### \<Sum>k\<in>?S1. if ?a1 = k then ?b1 k else (0::?'a1) \<equiv>
### if ?a1 \<in> ?S1 then ?b1 ?a1 else (0::?'a1)
### Ignoring duplicate rewrite rule:
### blinfun_apply 0 ?b1 \<equiv> 0::?'b1
### Ignoring duplicate rewrite rule:
### blinfun_apply ?a1 (0::?'a1) \<equiv> 0::?'b1
### Ignoring duplicate rewrite rule:
### finite ?S1 \<Longrightarrow>
### \<Sum>k\<in>?S1. if ?a1 = k then ?b1 k else (0::?'a1) \<equiv>
### if ?a1 \<in> ?S1 then ?b1 ?a1 else (0::?'a1)
### Ignoring duplicate rewrite rule:
### 0 < DIM(?'a1) \<equiv> True
### Ignoring duplicate rewrite rule:
### blinfun_apply 0 ?b1 \<equiv> 0::?'b1
### Ignoring duplicate rewrite rule:
### blinfun_apply ?a1 (0::?'a1) \<equiv> 0::?'b1
### Ignoring duplicate rewrite rule:
### blinfun_apply 0 ?b1 \<equiv> 0::?'b1
### Ignoring duplicate rewrite rule:
### blinfun_apply ?a1 (0::?'a1) \<equiv> 0::?'b1
### Ignoring duplicate rewrite rule:
### pathfinish ?g1.1 = pathstart ?g2.1 \<Longrightarrow>
### path (?g1.1 +++ ?g2.1) \<equiv> path ?g1.1 \<and> path ?g2.1
### Ignoring duplicate rewrite rule:
### pathfinish ?g1.1 = pathstart ?g2.1 \<Longrightarrow>
### path (?g1.1 +++ ?g2.1) \<equiv> path ?g1.1 \<and> path ?g2.1
### Ignoring duplicate rewrite rule:
### pathfinish ?g1.1 = pathstart ?g2.1 \<Longrightarrow>
### path (?g1.1 +++ ?g2.1) \<equiv> path ?g1.1 \<and> path ?g2.1
### Ignoring duplicate rewrite rule:
### blinfun_apply 0 ?b1 \<equiv> 0::?'b1
### Ignoring duplicate rewrite rule:
### blinfun_apply ?a1 (0::?'a1) \<equiv> 0::?'b1
### Ignoring duplicate rewrite rule:
### blinfun_apply 0 ?b1 \<equiv> 0::?'b1
### Ignoring duplicate rewrite rule:
### blinfun_apply ?a1 (0::?'a1) \<equiv> 0::?'b1
### Metis: Unused theorems: "Real.less_eq_real_def"
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Ignoring duplicate safe introduction (intro!)
### convex {?a..}
### Ignoring duplicate safe introduction (intro!)
### convex {..?b}
### Ignoring duplicate safe introduction (intro!)
### convex {?a<..}
### Ignoring duplicate safe introduction (intro!)
### convex {..<?b}
### Ignoring duplicate safe introduction (intro!)
### convex {?a..?b}
### Ignoring duplicate safe introduction (intro!)
### convex {?a<..?b}
### Ignoring duplicate safe introduction (intro!)
### convex {?a..<?b}
### Ignoring duplicate safe introduction (intro!)
### convex {?a<..<?b}
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### path_connected (path_component_set ?s1 ?x1) \<equiv> True
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Ignoring duplicate rewrite rule:
### path_connected {} \<equiv> True
### Ignoring duplicate rewrite rule:
### path_connected {?a1} \<equiv> True
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### connected_component_set UNIV ?x1 \<equiv> UNIV
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate introduction (intro)
### open {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### closed {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### closed UNIV
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Ignoring duplicate introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Ignoring duplicate introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Ignoring duplicate introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Ignoring duplicate rewrite rule:
### convex (ball ?x1 ?e1) \<equiv> True
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Ignoring duplicate safe introduction (intro!)
### \<lbrakk>continuous_map ?X ?X' ?f; continuous_map ?X' ?X'' ?g\<rbrakk>
### \<Longrightarrow> continuous_map ?X ?X'' (?g \<circ> ?f)
### Rule already declared as introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### homotopic_with ?P1 ?X1 ?Y1 ?f1 ?f1 \<equiv>
### continuous_map ?X1 ?Y1 ?f1 \<and> ?P1 ?f1
### Metis: Unused theorems: "Convex_Euclidean_Space.closest_point_exists_2"
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Ignoring duplicate introduction (intro)
### open {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### closed {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### closed UNIV
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### open {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Ignoring duplicate introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Ignoring duplicate introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Ignoring duplicate introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Rule already declared as introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Ignoring duplicate introduction (intro)
### open {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### closed {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### closed UNIV
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Ignoring duplicate introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Ignoring duplicate introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Ignoring duplicate introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Ignoring duplicate introduction (intro)
### open {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### closed {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### closed UNIV
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Ignoring duplicate introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Ignoring duplicate introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Ignoring duplicate introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Metis: Unused theorems: "Path_Connected.path_image_reversepath"
### Metis: Unused theorems: "Orderings.linorder_class.not_le"
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Metis: Unused theorems: "Homotopy.homotopic_join_subpaths2", "Homotopy.homotopic_join_subpaths3"
### Metis: Unused theorems: "Homotopy.homotopic_join_subpaths3"
### Metis: Unused theorems: "Homotopy.homotopic_join_subpaths2"
### Metis: Unused theorems: "Homotopy.homotopic_join_subpaths2"
### Ignoring duplicate rewrite rule:
### ?y1 \<in> ball ?x1 ?e1 \<equiv> dist ?x1 ?y1 < ?e1
### Ignoring duplicate rewrite rule:
### blinfun_apply 0 ?b1 \<equiv> 0::?'b1
### Ignoring duplicate rewrite rule:
### blinfun_apply ?a1 (0::?'a1) \<equiv> 0::?'b1
### Ignoring duplicate rewrite rule:
### blinfun_apply 0 ?b1 \<equiv> 0::?'b1
### Ignoring duplicate rewrite rule:
### blinfun_apply ?a1 (0::?'a1) \<equiv> 0::?'b1
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Metis: Unused theorems: "Cartesian_Space.linear_matrix_vector_mul_eq", "Cartesian_Space.matrix_vector_mul_1", "Cartesian_Space.matrix_vector_mul_3"
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### \<chi>i. ?y $ i \<equiv> ?y
### Ignoring duplicate rewrite rule:
### \<Prod>x\<in>?A1. ?y1 \<equiv> ?y1 ^ card ?A1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Metis: Unused theorems: "local.less.prems_2", "local.less.prems_3", "local.less.prems_4"
### Metis: Unused theorems: "local.less.prems_1", "local.less.prems_3", "local.less.prems_4"
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### bounded {?a1..?b1} \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Metis: Unused theorems: "??.unknown"
### Metis: Unused theorems: "??.unknown"
### Metis: Unused theorems: "local.that_2"
### Metis: Unused theorems: "local.that_3"
### Rewrite rule not in simpset:
### numeral ?w1 \<le> ?b1 / ?c1 \<equiv>
### if (0::?'a1) < ?c1 then numeral ?w1 * ?c1 \<le> ?b1
### else if ?c1 < (0::?'a1) then ?b1 \<le> numeral ?w1 * ?c1
###      else numeral ?w1 \<le> (0::?'a1)
### Rewrite rule not in simpset:
### - numeral ?w1 \<le> ?b1 / ?c1 \<equiv>
### if (0::?'a1) < ?c1 then - numeral ?w1 * ?c1 \<le> ?b1
### else if ?c1 < (0::?'a1) then ?b1 \<le> - numeral ?w1 * ?c1
###      else - numeral ?w1 \<le> (0::?'a1)
### Rewrite rule not in simpset:
### ?b1 / ?c1 \<le> numeral ?w1 \<equiv>
### if (0::?'a1) < ?c1 then ?b1 \<le> numeral ?w1 * ?c1
### else if ?c1 < (0::?'a1) then numeral ?w1 * ?c1 \<le> ?b1
###      else (0::?'a1) \<le> numeral ?w1
### Rewrite rule not in simpset:
### ?b1 / ?c1 \<le> - numeral ?w1 \<equiv>
### if (0::?'a1) < ?c1 then ?b1 \<le> - numeral ?w1 * ?c1
### else if ?c1 < (0::?'a1) then - numeral ?w1 * ?c1 \<le> ?b1
###      else (0::?'a1) \<le> - numeral ?w1
### Rewrite rule not in simpset:
### numeral ?w1 < ?b1 / ?c1 \<equiv>
### if (0::?'a1) < ?c1 then numeral ?w1 * ?c1 < ?b1
### else if ?c1 < (0::?'a1) then ?b1 < numeral ?w1 * ?c1
###      else numeral ?w1 < (0::?'a1)
### Rewrite rule not in simpset:
### - numeral ?w1 < ?b1 / ?c1 \<equiv>
### if (0::?'a1) < ?c1 then - numeral ?w1 * ?c1 < ?b1
### else if ?c1 < (0::?'a1) then ?b1 < - numeral ?w1 * ?c1
###      else - numeral ?w1 < (0::?'a1)
### Rewrite rule not in simpset:
### ?b1 / ?c1 < numeral ?w1 \<equiv>
### if (0::?'a1) < ?c1 then ?b1 < numeral ?w1 * ?c1
### else if ?c1 < (0::?'a1) then numeral ?w1 * ?c1 < ?b1
###      else (0::?'a1) < numeral ?w1
### Rewrite rule not in simpset:
### ?b1 / ?c1 < - numeral ?w1 \<equiv>
### if (0::?'a1) < ?c1 then ?b1 < - numeral ?w1 * ?c1
### else if ?c1 < (0::?'a1) then - numeral ?w1 * ?c1 < ?b1
###      else (0::?'a1) < - numeral ?w1
### Rewrite rule not in simpset:
### numeral ?w1 = ?b1 / ?c1 \<equiv>
### if ?c1 \<noteq> (0::?'a1) then numeral ?w1 * ?c1 = ?b1
### else numeral ?w1 = (0::?'a1)
### Rewrite rule not in simpset:
### - numeral ?w1 = ?b1 / ?c1 \<equiv>
### if ?c1 \<noteq> (0::?'a1) then - numeral ?w1 * ?c1 = ?b1
### else - numeral ?w1 = (0::?'a1)
### Rewrite rule not in simpset:
### ?b1 / ?c1 = numeral ?w1 \<equiv>
### if ?c1 \<noteq> (0::?'a1) then ?b1 = numeral ?w1 * ?c1
### else numeral ?w1 = (0::?'a1)
### Rewrite rule not in simpset:
### ?b1 / ?c1 = - numeral ?w1 \<equiv>
### if ?c1 \<noteq> (0::?'a1) then ?b1 = - numeral ?w1 * ?c1
### else - numeral ?w1 = (0::?'a1)
### Rewrite rule not in simpset:
### (1::?'a1) \<le> ?b1 / ?a1 \<equiv>
### (0::?'a1) < ?a1 \<and> ?a1 \<le> ?b1 \<or>
### ?a1 < (0::?'a1) \<and> ?b1 \<le> ?a1
### Rewrite rule not in simpset:
### ?b1 / ?a1 \<le> (1::?'a1) \<equiv>
### (0::?'a1) < ?a1 \<and> ?b1 \<le> ?a1 \<or>
### ?a1 < (0::?'a1) \<and> ?a1 \<le> ?b1 \<or> ?a1 = (0::?'a1)
### Rewrite rule not in simpset:
### (1::?'a1) < ?b1 / ?a1 \<equiv>
### (0::?'a1) < ?a1 \<and> ?a1 < ?b1 \<or> ?a1 < (0::?'a1) \<and> ?b1 < ?a1
### Rewrite rule not in simpset:
### ?b1 / ?a1 < (1::?'a1) \<equiv>
### (0::?'a1) < ?a1 \<and> ?b1 < ?a1 \<or>
### ?a1 < (0::?'a1) \<and> ?a1 < ?b1 \<or> ?a1 = (0::?'a1)
### Metis: Unused theorems: "local.that_1", "local.that_2"
### Ignoring duplicate rewrite rule:
### \<Prod>x\<in>?A1. ?y1 \<equiv> ?y1 ^ card ?A1
### Ignoring duplicate rewrite rule:
### \<Prod>x\<in>?A1. ?y1 \<equiv> ?y1 ^ card ?A1
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Ignoring duplicate rewrite rule:
### ?y1 \<in> ball ?x1 ?e1 \<equiv> dist ?x1 ?y1 < ?e1
### Ignoring duplicate rewrite rule:
### ?y1 \<in> cball ?x1 ?e1 \<equiv> dist ?x1 ?y1 \<le> ?e1
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Ignoring duplicate safe introduction (intro!)
### \<lbrakk>continuous_map ?X ?X' ?f; continuous_map ?X' ?X'' ?g\<rbrakk>
### \<Longrightarrow> continuous_map ?X ?X'' (?g \<circ> ?f)
### Ignoring duplicate safe introduction (intro!)
### continuous_map ?X ?X (\<lambda>x. x)
### Ignoring duplicate rewrite rule:
### ?y1 \<in> cball ?x1 ?e1 \<equiv> dist ?x1 ?y1 \<le> ?e1
### Ignoring duplicate rewrite rule:
### ?y1 \<in> cball ?x1 ?e1 \<equiv> dist ?x1 ?y1 \<le> ?e1
### Metis: Unused theorems: "??.unknown", "Path_Connected.arc_imp_path"
### Ignoring duplicate rewrite rule:
### topspace (product_topology ?T1 ?I1) \<equiv>
### \<Pi>\<^sub>E i\<in>?I1. topspace (?T1 i)
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Ignoring duplicate rewrite rule:
### ?y1 \<in> ball ?x1 ?e1 \<equiv> dist ?x1 ?y1 < ?e1
### Ignoring duplicate rewrite rule:
### ?y1 \<in> cball ?x1 ?e1 \<equiv> dist ?x1 ?y1 \<le> ?e1
### Ignoring duplicate rewrite rule:
### ?y1 \<in> cball ?x1 ?e1 \<equiv> dist ?x1 ?y1 \<le> ?e1
### Ignoring duplicate rewrite rule:
### ?y1 \<in> cball ?x1 ?e1 \<equiv> dist ?x1 ?y1 \<le> ?e1
### Metis: Unused theorems: "local.b_le_1"
### Metis: Unused theorems: "local.a_ge_0"
### Ignoring duplicate rewrite rule:
### \<Prod>x\<in>?A1. ?y1 \<equiv> ?y1 ^ card ?A1
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### ?y1 \<in> ball ?x1 ?e1 \<equiv> dist ?x1 ?y1 < ?e1
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### ?y1 \<in> ball ?x1 ?e1 \<equiv> dist ?x1 ?y1 < ?e1
### Ignoring duplicate rewrite rule:
### ?y1 \<in> cball ?x1 ?e1 \<equiv> dist ?x1 ?y1 \<le> ?e1
### Ignoring duplicate rewrite rule:
### path_connected {} \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### open {} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed UNIV \<equiv> True
### Ignoring duplicate rewrite rule:
### closed ?S1 \<Longrightarrow> closed (insert ?a1 ?S1) \<equiv> True
### Ignoring duplicate rewrite rule:
### open {?a1<..} \<equiv> True
### Ignoring duplicate rewrite rule:
### open {..<?a1} \<equiv> True
### Ignoring duplicate rewrite rule:
### open {?a1<..<?b1} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {..?a1} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {?a1..} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {?a1..?b1} \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 id \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous bot ?f1 \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous (at ?x1 within ?S1) (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous (at ?x1 within ?S1) id \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous ?F1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; isCont ?g1 ?a1; ?g1 ?a1 \<noteq> (0::?'b1)\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. ?f1 x / ?g1 x) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; isCont ?g1 ?a1; 0 < ?f1 ?a1; ?f1 ?a1 \<noteq> 1;
###  0 < ?g1 ?a1\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. log (?f1 x) (?g1 x)) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; isCont ?g1 ?a1; ?f1 ?a1 \<noteq> 0\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. ?f1 x powr ?g1 x) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; cos (?f1 ?a1) \<noteq> (0::?'a1)\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. tan (?f1 x)) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; sin (?f1 ?a1) \<noteq> (0::?'a1)\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. cot (?f1 x)) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous ?F1 ?g1 \<Longrightarrow>
### continuous ?F1 (\<lambda>x. cnj (?g1 x)) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 ?g1 \<Longrightarrow>
### continuous_on ?s1 (\<lambda>x. cnj (?g1 x)) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_map ?X1 ?X1 id \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_map ?X1 ?X1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### affine T \<equiv> True
### Ignoring duplicate rewrite rule:
### \<Prod>x\<in>?A1. ?y1 \<equiv> ?y1 ^ card ?A1
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### (\<lambda>z. ?c1) analytic_on ?S1 \<equiv> True
### Ignoring duplicate rewrite rule:
### deriv (\<lambda>w. ?c1) \<equiv> \<lambda>z. 0::?'a1
### Ignoring duplicate rewrite rule:
### (\<lambda>z. ?c1) analytic_on ?S1 \<equiv> True
### Ignoring duplicate rewrite rule:
### deriv (\<lambda>w. ?c1) \<equiv> \<lambda>z. 0::?'a1
### Ignoring duplicate rewrite rule:
### (\<lambda>z. ?c1) analytic_on ?S1 \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Metis: Unused theorems: "??.unknown"
### Ignoring duplicate rewrite rule:
### ?a1 \<in> closed_segment ?a1 ?b1 \<equiv> True
### Ignoring duplicate rewrite rule:
### ?b1 \<in> closed_segment ?a1 ?b1 \<equiv> True
### Ignoring duplicate introduction (intro)
### open {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### closed {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### closed UNIV
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Ignoring duplicate introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Ignoring duplicate introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Ignoring duplicate introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Metis: Unused theorems: "local.b"
### Metis: Unused theorems: "local.a"
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### closed (affine hull ?S1) \<equiv> True
### Ignoring duplicate rewrite rule:
### open {} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed UNIV \<equiv> True
### Ignoring duplicate rewrite rule:
### closed ?S1 \<Longrightarrow> closed (insert ?a1 ?S1) \<equiv> True
### Ignoring duplicate rewrite rule:
### open {?a1<..} \<equiv> True
### Ignoring duplicate rewrite rule:
### open {..<?a1} \<equiv> True
### Ignoring duplicate rewrite rule:
### open {?a1<..<?b1} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {..?a1} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {?a1..} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {?a1..?b1} \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 id \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous bot ?f1 \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous (at ?x1 within ?S1) (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous (at ?x1 within ?S1) id \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous ?F1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; isCont ?g1 ?a1; ?g1 ?a1 \<noteq> (0::?'b1)\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. ?f1 x / ?g1 x) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; isCont ?g1 ?a1; 0 < ?f1 ?a1; ?f1 ?a1 \<noteq> 1;
###  0 < ?g1 ?a1\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. log (?f1 x) (?g1 x)) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; isCont ?g1 ?a1; ?f1 ?a1 \<noteq> 0\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. ?f1 x powr ?g1 x) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; cos (?f1 ?a1) \<noteq> (0::?'a1)\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. tan (?f1 x)) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; sin (?f1 ?a1) \<noteq> (0::?'a1)\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. cot (?f1 x)) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous ?F1 ?g1 \<Longrightarrow>
### continuous ?F1 (\<lambda>x. cnj (?g1 x)) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 ?g1 \<Longrightarrow>
### continuous_on ?s1 (\<lambda>x. cnj (?g1 x)) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_map ?X1 ?X1 id \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_map ?X1 ?X1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### open {} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed UNIV \<equiv> True
### Ignoring duplicate rewrite rule:
### closed ?S1 \<Longrightarrow> closed (insert ?a1 ?S1) \<equiv> True
### Ignoring duplicate rewrite rule:
### open {?a1<..} \<equiv> True
### Ignoring duplicate rewrite rule:
### open {..<?a1} \<equiv> True
### Ignoring duplicate rewrite rule:
### open {?a1<..<?b1} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {..?a1} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {?a1..} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {?a1..?b1} \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 id \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous bot ?f1 \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous (at ?x1 within ?S1) (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous (at ?x1 within ?S1) id \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous ?F1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; isCont ?g1 ?a1; ?g1 ?a1 \<noteq> (0::?'b1)\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. ?f1 x / ?g1 x) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; isCont ?g1 ?a1; 0 < ?f1 ?a1; ?f1 ?a1 \<noteq> 1;
###  0 < ?g1 ?a1\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. log (?f1 x) (?g1 x)) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; isCont ?g1 ?a1; ?f1 ?a1 \<noteq> 0\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. ?f1 x powr ?g1 x) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; cos (?f1 ?a1) \<noteq> (0::?'a1)\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. tan (?f1 x)) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; sin (?f1 ?a1) \<noteq> (0::?'a1)\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. cot (?f1 x)) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous ?F1 ?g1 \<Longrightarrow>
### continuous ?F1 (\<lambda>x. cnj (?g1 x)) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 ?g1 \<Longrightarrow>
### continuous_on ?s1 (\<lambda>x. cnj (?g1 x)) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_map ?X1 ?X1 id \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_map ?X1 ?X1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate introduction (intro)
### open {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### closed {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### closed UNIV
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Ignoring duplicate introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Ignoring duplicate introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Ignoring duplicate rewrite rule:
### closed (affine hull ?S1) \<equiv> True
### Ignoring duplicate introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Rule already declared as introduction (intro)
### \<lbrakk>?a \<in> sigma_sets UNIV
###                    ((\<lambda>(a, i). {x. x \<bullet> i < a}) `
###                     (UNIV \<times> A));
###  ?b \<in> sigma_sets UNIV
###            ((\<lambda>(a, i). {x. x \<bullet> i < a}) `
###             (UNIV \<times> A))\<rbrakk>
### \<Longrightarrow> ?a - ?b
###                   \<in> sigma_sets UNIV
###                          ((\<lambda>(a, i). {x. x \<bullet> i < a}) `
###                           (UNIV \<times> A))
### Ignoring duplicate rewrite rule:
### 0 < DIM(?'a1) \<equiv> True
### Ignoring duplicate rewrite rule:
### 0 < DIM(?'a1) \<equiv> True
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Metis: Unused theorems: "local.g_1", "local.g_2", "local.g_3", "local.g_4", "local.h_1", "local.h_2"
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### contractible_space (Euclidean_space ?n1) \<equiv> True
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Ignoring duplicate rewrite rule:
### topspace (subtopology ?U1 ?V1) \<equiv> topspace ?U1 \<inter> ?V1
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Introduced fixed type variable(s): 'b in "Fa__" or "P__"
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Rule already declared as introduction (intro)
### (\<And>x y. ?A x y \<Longrightarrow> ?B (?f x) (?g y)) \<Longrightarrow>
### rel_fun ?A ?B ?f ?g
### Rule already declared as introduction (intro)
### (\<And>x. ?f x = ?g x) \<Longrightarrow> ?f = ?g
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### of_nat (Suc ?m1) \<equiv> (1::?'a1) + of_nat ?m1
### Metis: Unused theorems: "Complex.Im_rcis"
### Metis: Unused theorems: "Complex.Re_rcis"
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Metis: Unused theorems: "Transcendental.cos_minus", "Fields.division_ring_class.divide_minus_left"
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### of_nat (Suc ?m1) \<equiv> (1::?'a1) + of_nat ?m1
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### of_nat (Suc ?m1) \<equiv> (1::?'a1) + of_nat ?m1
### Ignoring duplicate rewrite rule:
### of_nat (Suc ?m1) \<equiv> (1::?'a1) + of_nat ?m1
### Ignoring duplicate rewrite rule:
### \<Prod>x\<in>?A1. ?y1 \<equiv> ?y1 ^ card ?A1
### Ignoring duplicate rewrite rule:
### of_nat (Suc ?m1) \<equiv> (1::?'a1) + of_nat ?m1
### Rule already declared as elimination (elim)
### \<lbrakk>?A \<subseteq> ?B; ?c \<notin> ?A \<Longrightarrow> ?P;
###  ?c \<in> ?B \<Longrightarrow> ?P\<rbrakk>
### \<Longrightarrow> ?P
### Ignoring duplicate rewrite rule:
### of_nat (Suc ?m1) \<equiv> (1::?'a1) + of_nat ?m1
### Ignoring duplicate rewrite rule:
### 0 < DIM(?'a1) \<equiv> True
### Ignoring duplicate introduction (intro)
### open {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### closed {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### closed UNIV
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Ignoring duplicate introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Ignoring duplicate introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Ignoring duplicate introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Rule already declared as introduction (intro)
### ((\<lambda>x. x) \<longlongrightarrow> ?a) (at ?a within ?s)
### Rule already declared as introduction (intro)
### ((\<lambda>x. ?k) \<longlongrightarrow> ?k) ?F
### Rule already declared as introduction (intro)
### (?f \<longlongrightarrow> ?x) ?F \<Longrightarrow>
### ((\<lambda>x. ereal (?f x)) \<longlongrightarrow> ereal ?x) ?F
### Rule already declared as introduction (intro)
### (?f \<longlongrightarrow> ?x) ?F \<Longrightarrow>
### ((\<lambda>x. - ?f x) \<longlongrightarrow> - ?x) ?F
### Rule already declared as introduction (intro)
### \<lbrakk>\<bar>?c\<bar> \<noteq> \<infinity>;
###  (?f \<longlongrightarrow> ?x) ?F\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?c * ?f x) \<longlongrightarrow> ?c * ?x) ?F
### Rule already declared as introduction (intro)
### \<lbrakk>?x \<noteq> 0; (?f \<longlongrightarrow> ?x) ?F\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?c * ?f x) \<longlongrightarrow> ?c * ?x) ?F
### Rule already declared as introduction (intro)
### \<lbrakk>?y \<noteq> - \<infinity>; ?x \<noteq> - \<infinity>;
###  (?f \<longlongrightarrow> ?x) ?F\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?f x + ?y) \<longlongrightarrow> ?x + ?y) ?F
### Rule already declared as introduction (intro)
### \<lbrakk>\<bar>?y\<bar> \<noteq> \<infinity>;
###  (?f \<longlongrightarrow> ?x) ?F\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?f x + ?y) \<longlongrightarrow> ?x + ?y) ?F
### Rule already declared as introduction (intro)
### (?f \<longlongrightarrow> ?x) ?F \<Longrightarrow>
### ((\<lambda>x. ennreal (?f x)) \<longlongrightarrow> ennreal ?x) ?F
### Ignoring duplicate rewrite rule:
### finite ?S1 \<Longrightarrow>
### \<Sum>k\<in>?S1. if k = ?a1 then ?b1 k else (0::?'a1) \<equiv>
### if ?a1 \<in> ?S1 then ?b1 ?a1 else (0::?'a1)
### Ignoring duplicate rewrite rule:
### 0 \<in> Suc ` ?A1 \<equiv> False
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### dist (0::?'a1) ?x1 \<equiv> norm ?x1
### Ignoring duplicate rewrite rule:
### 0 < DIM(?'a1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Metis: Unused theorems: "local.S_2"
### Ignoring duplicate rewrite rule:
### 0 < DIM(?'a1) \<equiv> True
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### Fun.swap ?a1 ?b1 ?f1 ?a1 \<equiv> ?f1 ?b1
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Metis: Unused theorems: "Cartesian_Space.vector_3_1", "Cartesian_Space.vector_3_2", "Cartesian_Space.vector_3_3"
### Rule already declared as introduction (intro)
### \<lbrakk>?P ?x; ?x \<in> ?A\<rbrakk>
### \<Longrightarrow> \<exists>x\<in>?A. ?P x
### Ignoring duplicate rewrite rule:
### 0 \<le> Sigma_Algebra.measure ?M1 ?A1 \<equiv> True
### Ignoring duplicate rewrite rule:
### 0 \<le> Sigma_Algebra.measure ?M1 ?A1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### finite ?S1 \<Longrightarrow>
### \<Sum>k\<in>?S1. if k = ?a1 then ?b1 k else (0::?'a1) \<equiv>
### if ?a1 \<in> ?S1 then ?b1 ?a1 else (0::?'a1)
### Ignoring duplicate rewrite rule:
### of_real (numeral ?w1) \<equiv> numeral ?w1
### Ignoring duplicate rewrite rule:
### 0 \<le> enn2real ?x1 \<equiv> True
### Ignoring duplicate rewrite rule:
### 0 \<le> enn2real ?x1 \<equiv> True
### Ignoring duplicate rewrite rule:
### 0 \<le> enn2real ?x1 \<equiv> True
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### of_real (numeral ?w1) \<equiv> numeral ?w1
### Rule already declared as introduction (intro)
### (\<And>i.
###     i \<in> ?P \<Longrightarrow>
###     simple_function ?M (?f i)) \<Longrightarrow>
### simple_function ?M (\<lambda>x. \<Sum>i\<in>?P. ?f i x)
### Ignoring duplicate rewrite rule:
### 0 \<le> Sigma_Algebra.measure ?M1 ?A1 \<equiv> True
### Ignoring duplicate rewrite rule:
### 0 \<le> Sigma_Algebra.measure ?M1 ?A1 \<equiv> True
### Ignoring duplicate rewrite rule:
### 0 \<le> Sigma_Algebra.measure ?M1 ?A1 \<equiv> True
### Rule already declared as introduction (intro)
### \<lbrakk>?b = ?f ?x; ?x \<in> ?A\<rbrakk> \<Longrightarrow> ?b \<in> ?f ` ?A
### Ignoring duplicate rewrite rule:
### (\<And>i.
###     i \<in> ?P1 \<Longrightarrow>
###     simple_function ?M1 (?f1 i)) \<Longrightarrow>
### simple_function ?M1 (\<lambda>x. \<Sum>i\<in>?P1. ?f1 i x) \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>simple_function ?M1 ?f1; \<And>x. 0 \<le> ?f1 x;
###  simple_function ?M1 ?g1; \<And>x. 0 \<le> ?g1 x\<rbrakk>
### \<Longrightarrow> \<integral>\<^sup>S x. ?f1 x +
###    ?g1 x \<partial>?M1 \<equiv>
###                   integral\<^sup>S ?M1 ?f1 + integral\<^sup>S ?M1 ?g1
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Ignoring duplicate safe introduction (intro!)
### (\<And>i.
###     i \<in> ?I \<Longrightarrow> continuous ?F (?f i)) \<Longrightarrow>
### continuous ?F (\<lambda>x. \<Sum>i\<in>?I. ?f i x)
### Rule already declared as introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Ignoring duplicate rewrite rule:
### 0 \<le> Sigma_Algebra.measure ?M1 ?A1 \<equiv> True
### Rule already declared as introduction (intro)
### range ?A \<subseteq> sets ?M \<Longrightarrow>
### \<Union> (range ?A) \<in> sets ?M
### Rule already declared as introduction (intro)
### \<lbrakk>?a \<in> sets ?M; ?b \<in> sets ?M\<rbrakk>
### \<Longrightarrow> ?a - ?b \<in> sets ?M
### Rule already declared as introduction (intro)
### \<lbrakk>?a \<in> sets ?M; ?b \<in> sets ?M\<rbrakk>
### \<Longrightarrow> ?a - ?b \<in> sets ?M
### Ignoring duplicate rewrite rule:
### 0 \<le> Sigma_Algebra.measure ?M1 ?A1 \<equiv> True
### Rule already declared as introduction (intro)
### (\<And>x. ?f x = ?g x) \<Longrightarrow> ?f = ?g
### Ignoring duplicate rewrite rule:
### ?A1 \<in> sets ?M1 \<Longrightarrow>
### simple_function ?M1 (indicator ?A1) \<equiv> True
### Ignoring duplicate rewrite rule:
### {?y1} \<in> sets ?M1 \<Longrightarrow>
### \<integral>\<^sup>+ x. ?f1 x * indicator {?y1} x \<partial>?M1 \<equiv>
### ?f1 ?y1 * emeasure ?M1 {?y1}
### Ignoring duplicate rewrite rule:
### path (linepath ?a1 ?b1) \<equiv> True
### Ignoring duplicate rewrite rule:
### vector [?y, ?y1] $ (1::?'b1) \<equiv> ?y
### Ignoring duplicate rewrite rule:
### vector [?x1, ?y] $ 2 \<equiv> ?y
### Rule already declared as introduction (intro)
### (\<And>x. x \<in> space ?M \<Longrightarrow> ?P x) \<Longrightarrow>
### almost_everywhere ?M ?P
### Rule already declared as introduction (intro)
### (\<And>x. x \<in> space ?M \<Longrightarrow> ?P x) \<Longrightarrow>
### almost_everywhere ?M ?P
### Rule already declared as introduction (intro)
### (\<And>x. x \<in> space ?M \<Longrightarrow> ?P x) \<Longrightarrow>
### almost_everywhere ?M ?P
### Rule already declared as introduction (intro)
### ?P ?x \<Longrightarrow> \<exists>x. ?P x
### Rule already declared as introduction (intro)
### \<lbrakk>?a \<in> sets ?M; ?b \<in> sets ?M\<rbrakk>
### \<Longrightarrow> ?a \<inter> ?b \<in> sets ?M
### Rule already declared as introduction (intro)
### \<lbrakk>?b = ?f ?x; ?x \<in> ?A\<rbrakk> \<Longrightarrow> ?b \<in> ?f ` ?A
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate safe introduction (intro!)
### (\<And>x. x \<in> ?A \<Longrightarrow> x \<in> ?B) \<Longrightarrow>
### ?A \<subseteq> ?B
### Rule already declared as introduction (intro)
### \<lbrakk>?x \<in> sets ?A; ?y \<in> sets ?B\<rbrakk>
### \<Longrightarrow> ?x \<times> ?y \<in> sets (?A \<Otimes>\<^sub>M ?B)
### Rule already declared as introduction (intro)
### \<lbrakk>?J \<subseteq> ?L; ?X \<in> sets (Pi\<^sub>M ?J ?M)\<rbrakk>
### \<Longrightarrow> prod_emb ?L ?M ?J ?X \<in> sets (Pi\<^sub>M ?L ?M)
### Ignoring duplicate rewrite rule:
### f (0::'a) \<equiv> 0::'b
### Ignoring duplicate rewrite rule:
### \<lbrakk>\<forall>\<^sub>F x in ?F1. 0 \<le> ?f1 x; 0 \<le> ?x1\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ennreal (?f1 x)) \<longlongrightarrow>
###                    ennreal ?x1)
###                    ?F1 \<equiv>
###                   (?f1 \<longlongrightarrow> ?x1) ?F1
### Ignoring duplicate introduction (intro)
### ((\<lambda>x. x) \<longlongrightarrow> ?a) (at ?a within ?s)
### Ignoring duplicate introduction (intro)
### ((\<lambda>x. ?k) \<longlongrightarrow> ?k) ?F
### Ignoring duplicate introduction (intro)
### (?f \<longlongrightarrow> ?x) ?F \<Longrightarrow>
### ((\<lambda>x. ereal (?f x)) \<longlongrightarrow> ereal ?x) ?F
### Ignoring duplicate introduction (intro)
### (?f \<longlongrightarrow> ?x) ?F \<Longrightarrow>
### ((\<lambda>x. - ?f x) \<longlongrightarrow> - ?x) ?F
### Ignoring duplicate introduction (intro)
### \<lbrakk>\<bar>?c\<bar> \<noteq> \<infinity>;
###  (?f \<longlongrightarrow> ?x) ?F\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?c * ?f x) \<longlongrightarrow> ?c * ?x) ?F
### Ignoring duplicate introduction (intro)
### \<lbrakk>?x \<noteq> 0; (?f \<longlongrightarrow> ?x) ?F\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?c * ?f x) \<longlongrightarrow> ?c * ?x) ?F
### Ignoring duplicate introduction (intro)
### \<lbrakk>?y \<noteq> - \<infinity>; ?x \<noteq> - \<infinity>;
###  (?f \<longlongrightarrow> ?x) ?F\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?f x + ?y) \<longlongrightarrow> ?x + ?y) ?F
### Ignoring duplicate introduction (intro)
### \<lbrakk>\<bar>?y\<bar> \<noteq> \<infinity>;
###  (?f \<longlongrightarrow> ?x) ?F\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?f x + ?y) \<longlongrightarrow> ?x + ?y) ?F
### Ignoring duplicate introduction (intro)
### (?f \<longlongrightarrow> ?x) ?F \<Longrightarrow>
### ((\<lambda>x. ennreal (?f x)) \<longlongrightarrow> ennreal ?x) ?F
### Rule already declared as safe introduction (intro!)
### True
### Ignoring duplicate introduction (intro)
### ((\<lambda>x. x) \<longlongrightarrow> ?a) (at ?a within ?s)
### Ignoring duplicate introduction (intro)
### ((\<lambda>x. ?k) \<longlongrightarrow> ?k) ?F
### Ignoring duplicate introduction (intro)
### (?f \<longlongrightarrow> ?x) ?F \<Longrightarrow>
### ((\<lambda>x. ereal (?f x)) \<longlongrightarrow> ereal ?x) ?F
### Ignoring duplicate introduction (intro)
### (?f \<longlongrightarrow> ?x) ?F \<Longrightarrow>
### ((\<lambda>x. - ?f x) \<longlongrightarrow> - ?x) ?F
### Ignoring duplicate introduction (intro)
### \<lbrakk>\<bar>?c\<bar> \<noteq> \<infinity>;
###  (?f \<longlongrightarrow> ?x) ?F\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?c * ?f x) \<longlongrightarrow> ?c * ?x) ?F
### Ignoring duplicate introduction (intro)
### \<lbrakk>?x \<noteq> 0; (?f \<longlongrightarrow> ?x) ?F\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?c * ?f x) \<longlongrightarrow> ?c * ?x) ?F
### Ignoring duplicate introduction (intro)
### \<lbrakk>?y \<noteq> - \<infinity>; ?x \<noteq> - \<infinity>;
###  (?f \<longlongrightarrow> ?x) ?F\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?f x + ?y) \<longlongrightarrow> ?x + ?y) ?F
### Ignoring duplicate introduction (intro)
### \<lbrakk>\<bar>?y\<bar> \<noteq> \<infinity>;
###  (?f \<longlongrightarrow> ?x) ?F\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?f x + ?y) \<longlongrightarrow> ?x + ?y) ?F
### Ignoring duplicate introduction (intro)
### (?f \<longlongrightarrow> ?x) ?F \<Longrightarrow>
### ((\<lambda>x. ennreal (?f x)) \<longlongrightarrow> ennreal ?x) ?F
### Ignoring duplicate rewrite rule:
### integrable ?M1 (\<lambda>x. ?c1 * ?f1 x) \<equiv>
### ?c1 = 0 \<or> integrable ?M1 ?f1
### Ignoring duplicate rewrite rule:
### integrable ?M1 (\<lambda>x. ?c1 * ?f1 x) \<equiv>
### ?c1 = 0 \<or> integrable ?M1 ?f1
### Ignoring duplicate rewrite rule:
### integrable ?M1 (\<lambda>x. ?c1 * ?f1 x) \<equiv>
### ?c1 = 0 \<or> integrable ?M1 ?f1
### Rule already declared as introduction (intro)
### (?c \<noteq> (0::?'b) \<Longrightarrow> integrable ?M ?f) \<Longrightarrow>
### integrable ?M (\<lambda>x. ?c * ?f x)
### Rule already declared as introduction (intro)
### (?c \<noteq> (0::?'b) \<Longrightarrow> integrable ?M ?f) \<Longrightarrow>
### integrable ?M (\<lambda>x. ?f x / ?c)
### Rule already declared as introduction (intro)
### \<lbrakk>?A \<in> sets ?M; emeasure ?M ?A < \<infinity>\<rbrakk>
### \<Longrightarrow> integrable ?M (indicat_real ?A)
### Rule already declared as introduction (intro)
### (\<And>x. x \<in> space ?M \<Longrightarrow> ?P x) \<Longrightarrow>
### almost_everywhere ?M ?P
### Metis: Unused theorems: "Set_Integral.set_integrable_def"
### Rule already declared as introduction (intro)
### (?c \<noteq> (0::?'b) \<Longrightarrow>
###  ?f abs_summable_on ?A) \<Longrightarrow>
### (\<lambda>x. ?c * ?f x) abs_summable_on ?A
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### \<Prod>x\<in>?A1. ?y1 \<equiv> ?y1 ^ card ?A1
### Ignoring duplicate rewrite rule:
### 0 < DIM(?'a1) \<equiv> True
### Ignoring duplicate rewrite rule:
### \<Prod>x\<in>?A1. ?y1 \<equiv> ?y1 ^ card ?A1
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### NO_MATCH (?x1 div ?y1) ?a1 \<Longrightarrow>
### ?a1 * (?b1 + ?c1) \<equiv> ?a1 * ?b1 + ?a1 * ?c1
### Ignoring duplicate rewrite rule:
### NO_MATCH (?x1 div ?y1) ?c1 \<Longrightarrow>
### (?a1 + ?b1) * ?c1 \<equiv> ?a1 * ?c1 + ?b1 * ?c1
### Ignoring duplicate rewrite rule:
### NO_MATCH (?x1 div ?y1) ?c1 \<Longrightarrow>
### (?a1 - ?b1) * ?c1 \<equiv> ?a1 * ?c1 - ?b1 * ?c1
### Ignoring duplicate rewrite rule:
### NO_MATCH (?x1 div ?y1) ?a1 \<Longrightarrow>
### ?a1 * (?b1 - ?c1) \<equiv> ?a1 * ?b1 - ?a1 * ?c1
### Ignoring duplicate rewrite rule:
### inverse ?a1 \<equiv> (1::?'a1) / ?a1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### inverse ?a1 ^ ?n1 \<equiv> inverse (?a1 ^ ?n1)
### Ignoring duplicate rewrite rule:
### ((1::?'a1) / ?a1) ^ ?n1 \<equiv> (1::?'a1) / ?a1 ^ ?n1
### Ignoring duplicate rewrite rule:
### (?a1 / ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 / ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### NO_MATCH (?x1 div ?y1) ?c1 \<Longrightarrow>
### (?a1 + ?b1) *\<^sub>R ?x1 \<equiv> ?a1 *\<^sub>R ?x1 + ?b1 *\<^sub>R ?x1
### Ignoring duplicate rewrite rule:
### NO_MATCH (?x1 div ?y1) ?a1 \<Longrightarrow>
### ?a1 *\<^sub>R (?x1 + ?y1) \<equiv> ?a1 *\<^sub>R ?x1 + ?a1 *\<^sub>R ?y1
### Ignoring duplicate rewrite rule:
### NO_MATCH (?x1 div ?y1) ?c1 \<Longrightarrow>
### (?a1 - ?b1) *\<^sub>R ?x1 \<equiv> ?a1 *\<^sub>R ?x1 - ?b1 *\<^sub>R ?x1
### Ignoring duplicate rewrite rule:
### NO_MATCH (?x1 div ?y1) ?a1 \<Longrightarrow>
### ?a1 *\<^sub>R (?x1 - ?y1) \<equiv> ?a1 *\<^sub>R ?x1 - ?a1 *\<^sub>R ?y1
### Ignoring duplicate rewrite rule:
### NO_MATCH (?x1 div ?y1) ?c1 \<Longrightarrow>
### (?a1 + ?b1) *s ?x1 \<equiv> ?a1 *s ?x1 + ?b1 *s ?x1
### Ignoring duplicate rewrite rule:
### NO_MATCH (?x1 div ?y1) ?a1 \<Longrightarrow>
### ?a1 *s (?x1 + ?y1) \<equiv> ?a1 *s ?x1 + ?a1 *s ?y1
### Ignoring duplicate rewrite rule:
### NO_MATCH (?x1 div ?y1) ?c1 \<Longrightarrow>
### (?a1 - ?b1) *s ?x1 \<equiv> ?a1 *s ?x1 - ?b1 *s ?x1
### Ignoring duplicate rewrite rule:
### NO_MATCH (?x1 div ?y1) ?a1 \<Longrightarrow>
### ?a1 *s (?x1 - ?y1) \<equiv> ?a1 *s ?x1 - ?a1 *s ?y1
### Ignoring duplicate rewrite rule:
### NO_MATCH (?x1 / ?y1) ?c1 \<Longrightarrow>
### (?a1 + ?b1) * ?x1 \<equiv> ?a1 * ?x1 + ?b1 * ?x1
### Ignoring duplicate rewrite rule:
### NO_MATCH (?x1 / ?y1) ?a1 \<Longrightarrow>
### ?a1 * (?x1 + ?y1) \<equiv> ?a1 * ?x1 + ?a1 * ?y1
### Ignoring duplicate rewrite rule:
### NO_MATCH (?x1 / ?y1) ?c1 \<Longrightarrow>
### (?a1 - ?b1) * ?x1 \<equiv> ?a1 * ?x1 - ?b1 * ?x1
### Ignoring duplicate rewrite rule:
### NO_MATCH (?x1 / ?y1) ?a1 \<Longrightarrow>
### ?a1 * (?x1 - ?y1) \<equiv> ?a1 * ?x1 - ?a1 * ?y1
### Rule already declared as introduction (intro)
### (?c \<noteq> (0::?'b) \<Longrightarrow> integrable ?M ?f) \<Longrightarrow>
### integrable ?M (\<lambda>x. ?f x * ?c)
### Ignoring duplicate rewrite rule:
### \<Prod>x\<in>?A1. ?y1 \<equiv> ?y1 ^ card ?A1
### Metis: Unused theorems: "Tagged_Division.interval_bounds'_2"
### Metis: Unused theorems: "Tagged_Division.interval_bounds'_1"
### Metis: Unused theorems: "local.assms_6"
### Metis: Unused theorems: "local.assms_6"
### Ignoring duplicate introduction (intro)
### ?f integrable_on ?i \<Longrightarrow> (?f has_integral integral ?i ?f) ?i
### Ignoring duplicate introduction (intro)
### ?f integrable_on ?i \<Longrightarrow> (?f has_integral integral ?i ?f) ?i
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Metis: Unused theorems: "local.assms_1", "Tagged_Division.division_ofD_4"
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
Failure node
Enter MATCH
\<lambda>x _ i a b c d e f g h j k l m n o p q r s t u v w y z aa.
   :002
    (\<lambda>i.
        :001
         (?n62 a b c d e f g h j k l m n o p q r s t u v w y z aa
           i)) \<equiv>\<^sup>?
\<lambda>x _ i. ?n61
?n61 \<equiv>\<^sup>?
?n62
 (:002
   (\<lambda>a.
       :001
        (:002
          (\<lambda>b.
              :001
               (:002
                 (\<lambda>c.
                     :001
                      (:002
                        (\<lambda>d.
                            :001
                             (:002
                               (\<lambda>e.
                                   :001
                                    (:002
(\<lambda>f.
    :001
     (:002
       (\<lambda>g.
           :001
            (:002
              (\<lambda>h.
                  :001
                   (:002
                     (\<lambda>i.
                         :001
                          (:002
                            (\<lambda>j.
                                :001
                                 (:002
                                   (\<lambda>k.
 :001
  (:002
    (\<lambda>l.
        :001
         (:002
           (\<lambda>m.
               :001
                (:002
                  (\<lambda>n.
                      :001
                       (:002
                         (\<lambda>o.
                             :001
                              (:002
                                (\<lambda>p.
                                    :001
                                     (:002
 (\<lambda>q.
     :001
      (:002
        (\<lambda>r.
            :001
             (:002
               (\<lambda>s.
                   :001
                    (:002
                      (\<lambda>t.
                          :001
                           (:002
                             (\<lambda>u.
                                 :001
                                  (:002
                                    (\<lambda>v.
  :001
   (:002
     (\<lambda>w.
         :001
          (:002
            (\<lambda>x.
                :001
                 (:002
                   (\<lambda>y.
                       :001
                        (:002
                          (\<lambda>z.
                              :001
                               (?n62 a b c d e f g h i j k l m n o p q r s t
                                 u v w x y
                                 z)))))))))))))))))))))))))))))))))))))))))))))))))))))
Enter MATCH
\<lambda>a b c d e f g h i j k l m n o p q r s t u v w x y.
   :002
    (\<lambda>z.
        :001
         (?n63 a b c d e f g h i j k l m n o p q r s t u v w x y
           z)) \<equiv>\<^sup>?
?n62
 (:002
   (\<lambda>a.
       :001
        (:002
          (\<lambda>b.
              :001
               (:002
                 (\<lambda>c.
                     :001
                      (:002
                        (\<lambda>d.
                            :001
                             (:002
                               (\<lambda>e.
                                   :001
                                    (:002
(\<lambda>f.
    :001
     (:002
       (\<lambda>g.
           :001
            (:002
              (\<lambda>h.
                  :001
                   (:002
                     (\<lambda>i.
                         :001
                          (:002
                            (\<lambda>j.
                                :001
                                 (:002
                                   (\<lambda>k.
 :001
  (:002
    (\<lambda>l.
        :001
         (:002
           (\<lambda>m.
               :001
                (:002
                  (\<lambda>n.
                      :001
                       (:002
                         (\<lambda>o.
                             :001
                              (:002
                                (\<lambda>p.
                                    :001
                                     (:002
 (\<lambda>q.
     :001
      (:002
        (\<lambda>r.
            :001
             (:002
               (\<lambda>s.
                   :001
                    (:002
                      (\<lambda>t.
                          :001
                           (:002
                             (\<lambda>u.
                                 :001
                                  (:002
                                    (\<lambda>v.
  :001
   (:002
     (\<lambda>w.
         :001
          (:002
            (\<lambda>x.
                :001
                 (:002
                   (\<lambda>y.
                       :001
                        (:002
                          (\<lambda>z.
                              :001
                               (?n62 a b c d e f g h i j k l m n o p q r s t
                                 u v w x y
                                 z)))))))))))))))))))))))))))))))))))))))))))))))))))))
\<lambda>x _ i. ?n62 \<equiv>\<^sup>? \<lambda>x _ i. ?n63
Failure node
Enter MATCH
\<lambda>x _ i a b c d e f g h j k l m n o p q r s t u v w y z aa ab.
   :002
    (\<lambda>i.
        :001
         (?n64 a b c d e f g h j k l m n o p q r s t u v w y z aa ab
           i)) \<equiv>\<^sup>?
\<lambda>x _ i. ?n63
?n63 \<equiv>\<^sup>?
?n64
 (:002
   (\<lambda>a.
       :001
        (:002
          (\<lambda>b.
              :001
               (:002
                 (\<lambda>c.
                     :001
                      (:002
                        (\<lambda>d.
                            :001
                             (:002
                               (\<lambda>e.
                                   :001
                                    (:002
(\<lambda>f.
    :001
     (:002
       (\<lambda>g.
           :001
            (:002
              (\<lambda>h.
                  :001
                   (:002
                     (\<lambda>i.
                         :001
                          (:002
                            (\<lambda>j.
                                :001
                                 (:002
                                   (\<lambda>k.
 :001
  (:002
    (\<lambda>l.
        :001
         (:002
           (\<lambda>m.
               :001
                (:002
                  (\<lambda>n.
                      :001
                       (:002
                         (\<lambda>o.
                             :001
                              (:002
                                (\<lambda>p.
                                    :001
                                     (:002
 (\<lambda>q.
     :001
      (:002
        (\<lambda>r.
            :001
             (:002
               (\<lambda>s.
                   :001
                    (:002
                      (\<lambda>t.
                          :001
                           (:002
                             (\<lambda>u.
                                 :001
                                  (:002
                                    (\<lambda>v.
  :001
   (:002
     (\<lambda>w.
         :001
          (:002
            (\<lambda>x.
                :001
                 (:002
                   (\<lambda>y.
                       :001
                        (:002
                          (\<lambda>z.
                              :001
                               (:002
                                 (\<lambda>aa.
                                     :001
(?n64 a b c d e f g h i j k l m n o p q r s t u v w x y z
  aa)))))))))))))))))))))))))))))))))))))))))))))))))))))))
Enter MATCH
\<lambda>a b c d e f g h i j k l m n o p q r s t u v w x y z.
   :002
    (\<lambda>aa.
        :001
         (?n65 a b c d e f g h i j k l m n o p q r s t u v w x y z
           aa)) \<equiv>\<^sup>?
?n64
 (:002
   (\<lambda>a.
       :001
        (:002
          (\<lambda>b.
              :001
               (:002
                 (\<lambda>c.
                     :001
                      (:002
                        (\<lambda>d.
                            :001
                             (:002
                               (\<lambda>e.
                                   :001
                                    (:002
(\<lambda>f.
    :001
     (:002
       (\<lambda>g.
           :001
            (:002
              (\<lambda>h.
                  :001
                   (:002
                     (\<lambda>i.
                         :001
                          (:002
                            (\<lambda>j.
                                :001
                                 (:002
                                   (\<lambda>k.
 :001
  (:002
    (\<lambda>l.
        :001
         (:002
           (\<lambda>m.
               :001
                (:002
                  (\<lambda>n.
                      :001
                       (:002
                         (\<lambda>o.
                             :001
                              (:002
                                (\<lambda>p.
                                    :001
                                     (:002
 (\<lambda>q.
     :001
      (:002
        (\<lambda>r.
            :001
             (:002
               (\<lambda>s.
                   :001
                    (:002
                      (\<lambda>t.
                          :001
                           (:002
                             (\<lambda>u.
                                 :001
                                  (:002
                                    (\<lambda>v.
  :001
   (:002
     (\<lambda>w.
         :001
          (:002
            (\<lambda>x.
                :001
                 (:002
                   (\<lambda>y.
                       :001
                        (:002
                          (\<lambda>z.
                              :001
                               (:002
                                 (\<lambda>aa.
                                     :001
(?n64 a b c d e f g h i j k l m n o p q r s t u v w x y z
  aa)))))))))))))))))))))))))))))))))))))))))))))))))))))))
\<lambda>x _ i. ?n64 \<equiv>\<^sup>? \<lambda>x _ i. ?n65
Failure node
Enter MATCH
\<lambda>x _ i a b c d e f g h j k l m n o p q r s t u v w y z aa ab ac.
   :002
    (\<lambda>i.
        :001
         (?n66 a b c d e f g h j k l m n o p q r s t u v w y z aa ab ac
           i)) \<equiv>\<^sup>?
\<lambda>x _ i. ?n65
?n65 \<equiv>\<^sup>?
?n66
 (:002
   (\<lambda>a.
       :001
        (:002
          (\<lambda>b.
              :001
               (:002
                 (\<lambda>c.
                     :001
                      (:002
                        (\<lambda>d.
                            :001
                             (:002
                               (\<lambda>e.
                                   :001
                                    (:002
(\<lambda>f.
    :001
     (:002
       (\<lambda>g.
           :001
            (:002
              (\<lambda>h.
                  :001
                   (:002
                     (\<lambda>i.
                         :001
                          (:002
                            (\<lambda>j.
                                :001
                                 (:002
                                   (\<lambda>k.
 :001
  (:002
    (\<lambda>l.
        :001
         (:002
           (\<lambda>m.
               :001
                (:002
                  (\<lambda>n.
                      :001
                       (:002
                         (\<lambda>o.
                             :001
                              (:002
                                (\<lambda>p.
                                    :001
                                     (:002
 (\<lambda>q.
     :001
      (:002
        (\<lambda>r.
            :001
             (:002
               (\<lambda>s.
                   :001
                    (:002
                      (\<lambda>t.
                          :001
                           (:002
                             (\<lambda>u.
                                 :001
                                  (:002
                                    (\<lambda>v.
  :001
   (:002
     (\<lambda>w.
         :001
          (:002
            (\<lambda>x.
                :001
                 (:002
                   (\<lambda>y.
                       :001
                        (:002
                          (\<lambda>z.
                              :001
                               (:002
                                 (\<lambda>aa.
                                     :001
(:002
  (\<lambda>ab.
      :001
       (?n66 a b c d e f g h i j k l m n o p q r s t u v w x y z aa
         ab)))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Enter MATCH
\<lambda>a b c d e f g h i j k l m n o p q r s t u v w x y z aa.
   :002
    (\<lambda>ab.
        :001
         (?n67 a b c d e f g h i j k l m n o p q r s t u v w x y z aa
           ab)) \<equiv>\<^sup>?
?n66
 (:002
   (\<lambda>a.
       :001
        (:002
          (\<lambda>b.
              :001
               (:002
                 (\<lambda>c.
                     :001
                      (:002
                        (\<lambda>d.
                            :001
                             (:002
                               (\<lambda>e.
                                   :001
                                    (:002
(\<lambda>f.
    :001
     (:002
       (\<lambda>g.
           :001
            (:002
              (\<lambda>h.
                  :001
                   (:002
                     (\<lambda>i.
                         :001
                          (:002
                            (\<lambda>j.
                                :001
                                 (:002
                                   (\<lambda>k.
 :001
  (:002
    (\<lambda>l.
        :001
         (:002
           (\<lambda>m.
               :001
                (:002
                  (\<lambda>n.
                      :001
                       (:002
                         (\<lambda>o.
                             :001
                              (:002
                                (\<lambda>p.
                                    :001
                                     (:002
 (\<lambda>q.
     :001
      (:002
        (\<lambda>r.
            :001
             (:002
               (\<lambda>s.
                   :001
                    (:002
                      (\<lambda>t.
                          :001
                           (:002
                             (\<lambda>u.
                                 :001
                                  (:002
                                    (\<lambda>v.
  :001
   (:002
     (\<lambda>w.
         :001
          (:002
            (\<lambda>x.
                :001
                 (:002
                   (\<lambda>y.
                       :001
                        (:002
                          (\<lambda>z.
                              :001
                               (:002
                                 (\<lambda>aa.
                                     :001
(:002
  (\<lambda>ab.
      :001
       (?n66 a b c d e f g h i j k l m n o p q r s t u v w x y z aa
         ab)))))))))))))))))))))))))))))))))))))))))))))))))))))))))
\<lambda>x _ i. ?n66 \<equiv>\<^sup>? \<lambda>x _ i. ?n67
Failure node
Enter MATCH
\<lambda>x _ i a b c d e f g h j k l m n o p q r s t u v w y z aa ab ac ad.
   :002
    (\<lambda>i.
        :001
         (?n68 a b c d e f g h j k l m n o p q r s t u v w y z aa ab ac ad
           i)) \<equiv>\<^sup>?
\<lambda>x _ i. ?n67
?n67 \<equiv>\<^sup>?
?n68
 (:002
   (\<lambda>a.
       :001
        (:002
          (\<lambda>b.
              :001
               (:002
                 (\<lambda>c.
                     :001
                      (:002
                        (\<lambda>d.
                            :001
                             (:002
                               (\<lambda>e.
                                   :001
                                    (:002
(\<lambda>f.
    :001
     (:002
       (\<lambda>g.
           :001
            (:002
              (\<lambda>h.
                  :001
                   (:002
                     (\<lambda>i.
                         :001
                          (:002
                            (\<lambda>j.
                                :001
                                 (:002
                                   (\<lambda>k.
 :001
  (:002
    (\<lambda>l.
        :001
         (:002
           (\<lambda>m.
               :001
                (:002
                  (\<lambda>n.
                      :001
                       (:002
                         (\<lambda>o.
                             :001
                              (:002
                                (\<lambda>p.
                                    :001
                                     (:002
 (\<lambda>q.
     :001
      (:002
        (\<lambda>r.
            :001
             (:002
               (\<lambda>s.
                   :001
                    (:002
                      (\<lambda>t.
                          :001
                           (:002
                             (\<lambda>u.
                                 :001
                                  (:002
                                    (\<lambda>v.
  :001
   (:002
     (\<lambda>w.
         :001
          (:002
            (\<lambda>x.
                :001
                 (:002
                   (\<lambda>y.
                       :001
                        (:002
                          (\<lambda>z.
                              :001
                               (:002
                                 (\<lambda>aa.
                                     :001
(:002
  (\<lambda>ab.
      :001
       (:002
         (\<lambda>ac.
             :001
              (?n68 a b c d e f g h i j k l m n o p q r s t u v w x y z aa
                ab ac)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Enter MATCH
\<lambda>a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab.
   :002
    (\<lambda>ac.
        :001
         (?n69 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab
           ac)) \<equiv>\<^sup>?
?n68
 (:002
   (\<lambda>a.
       :001
        (:002
          (\<lambda>b.
              :001
               (:002
                 (\<lambda>c.
                     :001
                      (:002
                        (\<lambda>d.
                            :001
                             (:002
                               (\<lambda>e.
                                   :001
                                    (:002
(\<lambda>f.
    :001
     (:002
       (\<lambda>g.
           :001
            (:002
              (\<lambda>h.
                  :001
                   (:002
                     (\<lambda>i.
                         :001
                          (:002
                            (\<lambda>j.
                                :001
                                 (:002
                                   (\<lambda>k.
 :001
  (:002
    (\<lambda>l.
        :001
         (:002
           (\<lambda>m.
               :001
                (:002
                  (\<lambda>n.
                      :001
                       (:002
                         (\<lambda>o.
                             :001
                              (:002
                                (\<lambda>p.
                                    :001
                                     (:002
 (\<lambda>q.
     :001
      (:002
        (\<lambda>r.
            :001
             (:002
               (\<lambda>s.
                   :001
                    (:002
                      (\<lambda>t.
                          :001
                           (:002
                             (\<lambda>u.
                                 :001
                                  (:002
                                    (\<lambda>v.
  :001
   (:002
     (\<lambda>w.
         :001
          (:002
            (\<lambda>x.
                :001
                 (:002
                   (\<lambda>y.
                       :001
                        (:002
                          (\<lambda>z.
                              :001
                               (:002
                                 (\<lambda>aa.
                                     :001
(:002
  (\<lambda>ab.
      :001
       (:002
         (\<lambda>ac.
             :001
              (?n68 a b c d e f g h i j k l m n o p q r s t u v w x y z aa
                ab ac)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
\<lambda>x _ i. ?n68 \<equiv>\<^sup>? \<lambda>x _ i. ?n69
Failure node
Enter MATCH
\<lambda>x _ i a b c d e f g h j k l m n o p q r s t u v w y z aa ab ac ad
   ae.
   :002
    (\<lambda>i.
        :001
         (?n70 a b c d e f g h j k l m n o p q r s t u v w y z aa ab ac ad
           ae i)) \<equiv>\<^sup>?
\<lambda>x _ i. ?n69
?n69 \<equiv>\<^sup>?
?n70
 (:002
   (\<lambda>a.
       :001
        (:002
          (\<lambda>b.
              :001
               (:002
                 (\<lambda>c.
                     :001
                      (:002
                        (\<lambda>d.
                            :001
                             (:002
                               (\<lambda>e.
                                   :001
                                    (:002
(\<lambda>f.
    :001
     (:002
       (\<lambda>g.
           :001
            (:002
              (\<lambda>h.
                  :001
                   (:002
                     (\<lambda>i.
                         :001
                          (:002
                            (\<lambda>j.
                                :001
                                 (:002
                                   (\<lambda>k.
 :001
  (:002
    (\<lambda>l.
        :001
         (:002
           (\<lambda>m.
               :001
                (:002
                  (\<lambda>n.
                      :001
                       (:002
                         (\<lambda>o.
                             :001
                              (:002
                                (\<lambda>p.
                                    :001
                                     (:002
 (\<lambda>q.
     :001
      (:002
        (\<lambda>r.
            :001
             (:002
               (\<lambda>s.
                   :001
                    (:002
                      (\<lambda>t.
                          :001
                           (:002
                             (\<lambda>u.
                                 :001
                                  (:002
                                    (\<lambda>v.
  :001
   (:002
     (\<lambda>w.
         :001
          (:002
            (\<lambda>x.
                :001
                 (:002
                   (\<lambda>y.
                       :001
                        (:002
                          (\<lambda>z.
                              :001
                               (:002
                                 (\<lambda>aa.
                                     :001
(:002
  (\<lambda>ab.
      :001
       (:002
         (\<lambda>ac.
             :001
              (:002
                (\<lambda>ad.
                    :001
                     (?n70 a b c d e f g h i j k l m n o p q r s t u v w x y
                       z aa ab ac
                       ad)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Enter MATCH
\<lambda>a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac.
   :002
    (\<lambda>ad.
        :001
         (?n71 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac
           ad)) \<equiv>\<^sup>?
?n70
 (:002
   (\<lambda>a.
       :001
        (:002
          (\<lambda>b.
              :001
               (:002
                 (\<lambda>c.
                     :001
                      (:002
                        (\<lambda>d.
                            :001
                             (:002
                               (\<lambda>e.
                                   :001
                                    (:002
(\<lambda>f.
    :001
     (:002
       (\<lambda>g.
           :001
            (:002
              (\<lambda>h.
                  :001
                   (:002
                     (\<lambda>i.
                         :001
                          (:002
                            (\<lambda>j.
                                :001
                                 (:002
                                   (\<lambda>k.
 :001
  (:002
    (\<lambda>l.
        :001
         (:002
           (\<lambda>m.
               :001
                (:002
                  (\<lambda>n.
                      :001
                       (:002
                         (\<lambda>o.
                             :001
                              (:002
                                (\<lambda>p.
                                    :001
                                     (:002
 (\<lambda>q.
     :001
      (:002
        (\<lambda>r.
            :001
             (:002
               (\<lambda>s.
                   :001
                    (:002
                      (\<lambda>t.
                          :001
                           (:002
                             (\<lambda>u.
                                 :001
                                  (:002
                                    (\<lambda>v.
  :001
   (:002
     (\<lambda>w.
         :001
          (:002
            (\<lambda>x.
                :001
                 (:002
                   (\<lambda>y.
                       :001
                        (:002
                          (\<lambda>z.
                              :001
                               (:002
                                 (\<lambda>aa.
                                     :001
(:002
  (\<lambda>ab.
      :001
       (:002
         (\<lambda>ac.
             :001
              (:002
                (\<lambda>ad.
                    :001
                     (?n70 a b c d e f g h i j k l m n o p q r s t u v w x y
                       z aa ab ac
                       ad)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
\<lambda>x _ i. ?n70 \<equiv>\<^sup>? \<lambda>x _ i. ?n71
Failure node
### Unification bound exceeded
### Introduced fixed type variable(s): 'c in "T__" or "g__"
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### \<Prod>x\<in>?A1. ?y1 \<equiv> ?y1 ^ card ?A1
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?r1 *\<^sub>R ?x1 \<bullet> ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Ignoring duplicate rewrite rule:
### ?x1 \<bullet> ?r1 *\<^sub>R ?y1 \<equiv> ?r1 * (?x1 \<bullet> ?y1)
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Introduced fixed type variable(s): 'b, 'c in "S__" or "fa__"
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Ignoring duplicate rewrite rule:
### blinfun_apply 0 ?b1 \<equiv> 0::?'b1
### Ignoring duplicate rewrite rule:
### blinfun_apply ?a1 (0::?'a1) \<equiv> 0::?'b1
### Ignoring duplicate rewrite rule:
### compact (cbox ?a1 ?b1) \<equiv> True
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Ignoring duplicate rewrite rule:
### 0 \<le> content ?X1 \<equiv> True
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### simple_function ?M ?f \<Longrightarrow>
### simple_function ?M (\<lambda>x. ennreal (?f x))
### Ignoring duplicate rewrite rule:
### 0 \<le> enn2real ?x1 \<equiv> True
### Rule already declared as introduction (intro)
### \<lbrakk>?a \<in> sets ?M; ?b \<in> sets ?M\<rbrakk>
### \<Longrightarrow> ?a \<inter> ?b \<in> sets ?M
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?I;
###  \<And>i. i \<in> ?I \<Longrightarrow> ?A i \<in> sets ?M\<rbrakk>
### \<Longrightarrow> \<Union> (?A ` ?I) \<in> sets ?M
### Ignoring duplicate safe introduction (intro!)
### (\<And>x. x \<in> ?A \<Longrightarrow> x \<in> ?B) \<Longrightarrow>
### ?A \<subseteq> ?B
### Rule already declared as introduction (intro)
### \<lbrakk>?a \<in> sets ?M; ?b \<in> sets ?M\<rbrakk>
### \<Longrightarrow> ?a \<inter> ?b \<in> sets ?M
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?I;
###  \<And>i. i \<in> ?I \<Longrightarrow> ?A i \<in> sets ?M\<rbrakk>
### \<Longrightarrow> \<Union> (?A ` ?I) \<in> sets ?M
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?I;
###  \<And>i. i \<in> ?I \<Longrightarrow> ?A i \<in> sets ?M\<rbrakk>
### \<Longrightarrow> \<Union> (?A ` ?I) \<in> sets ?M
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate introduction (intro)
### open {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### closed {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### closed UNIV
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Ignoring duplicate introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Ignoring duplicate introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Ignoring duplicate introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Ignoring duplicate introduction (intro)
### open {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### open {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Ignoring duplicate introduction (intro)
### closed {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### closed UNIV
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### closed {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### closed UNIV
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Ignoring duplicate introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Ignoring duplicate introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Ignoring duplicate introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Ignoring duplicate introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Ignoring duplicate introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Ignoring duplicate introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Ignoring duplicate introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<le> (0::?'a1) \<equiv>
### (0::?'a1) \<le> ?a1 \<and> ?b1 \<le> (0::?'a1) \<or>
### ?a1 \<le> (0::?'a1) \<and> (0::?'a1) \<le> ?b1
### Rewrite rule not in simpset:
### numeral ?w1 \<le> ?b1 / ?c1 \<equiv>
### if (0::?'a1) < ?c1 then numeral ?w1 * ?c1 \<le> ?b1
### else if ?c1 < (0::?'a1) then ?b1 \<le> numeral ?w1 * ?c1
###      else numeral ?w1 \<le> (0::?'a1)
### Rewrite rule not in simpset:
### - numeral ?w1 \<le> ?b1 / ?c1 \<equiv>
### if (0::?'a1) < ?c1 then - numeral ?w1 * ?c1 \<le> ?b1
### else if ?c1 < (0::?'a1) then ?b1 \<le> - numeral ?w1 * ?c1
###      else - numeral ?w1 \<le> (0::?'a1)
### Rewrite rule not in simpset:
### ?b1 / ?c1 \<le> numeral ?w1 \<equiv>
### if (0::?'a1) < ?c1 then ?b1 \<le> numeral ?w1 * ?c1
### else if ?c1 < (0::?'a1) then numeral ?w1 * ?c1 \<le> ?b1
###      else (0::?'a1) \<le> numeral ?w1
### Rewrite rule not in simpset:
### ?b1 / ?c1 \<le> - numeral ?w1 \<equiv>
### if (0::?'a1) < ?c1 then ?b1 \<le> - numeral ?w1 * ?c1
### else if ?c1 < (0::?'a1) then - numeral ?w1 * ?c1 \<le> ?b1
###      else (0::?'a1) \<le> - numeral ?w1
### Rewrite rule not in simpset:
### numeral ?w1 < ?b1 / ?c1 \<equiv>
### if (0::?'a1) < ?c1 then numeral ?w1 * ?c1 < ?b1
### else if ?c1 < (0::?'a1) then ?b1 < numeral ?w1 * ?c1
###      else numeral ?w1 < (0::?'a1)
### Rewrite rule not in simpset:
### - numeral ?w1 < ?b1 / ?c1 \<equiv>
### if (0::?'a1) < ?c1 then - numeral ?w1 * ?c1 < ?b1
### else if ?c1 < (0::?'a1) then ?b1 < - numeral ?w1 * ?c1
###      else - numeral ?w1 < (0::?'a1)
### Rewrite rule not in simpset:
### ?b1 / ?c1 < numeral ?w1 \<equiv>
### if (0::?'a1) < ?c1 then ?b1 < numeral ?w1 * ?c1
### else if ?c1 < (0::?'a1) then numeral ?w1 * ?c1 < ?b1
###      else (0::?'a1) < numeral ?w1
### Rewrite rule not in simpset:
### ?b1 / ?c1 < - numeral ?w1 \<equiv>
### if (0::?'a1) < ?c1 then ?b1 < - numeral ?w1 * ?c1
### else if ?c1 < (0::?'a1) then - numeral ?w1 * ?c1 < ?b1
###      else (0::?'a1) < - numeral ?w1
### Rewrite rule not in simpset:
### numeral ?w1 = ?b1 / ?c1 \<equiv>
### if ?c1 \<noteq> (0::?'a1) then numeral ?w1 * ?c1 = ?b1
### else numeral ?w1 = (0::?'a1)
### Rewrite rule not in simpset:
### - numeral ?w1 = ?b1 / ?c1 \<equiv>
### if ?c1 \<noteq> (0::?'a1) then - numeral ?w1 * ?c1 = ?b1
### else - numeral ?w1 = (0::?'a1)
### Rewrite rule not in simpset:
### ?b1 / ?c1 = numeral ?w1 \<equiv>
### if ?c1 \<noteq> (0::?'a1) then ?b1 = numeral ?w1 * ?c1
### else numeral ?w1 = (0::?'a1)
### Rewrite rule not in simpset:
### ?b1 / ?c1 = - numeral ?w1 \<equiv>
### if ?c1 \<noteq> (0::?'a1) then ?b1 = - numeral ?w1 * ?c1
### else - numeral ?w1 = (0::?'a1)
### Rewrite rule not in simpset:
### (1::?'a1) \<le> ?b1 / ?a1 \<equiv>
### (0::?'a1) < ?a1 \<and> ?a1 \<le> ?b1 \<or>
### ?a1 < (0::?'a1) \<and> ?b1 \<le> ?a1
### Rewrite rule not in simpset:
### ?b1 / ?a1 \<le> (1::?'a1) \<equiv>
### (0::?'a1) < ?a1 \<and> ?b1 \<le> ?a1 \<or>
### ?a1 < (0::?'a1) \<and> ?a1 \<le> ?b1 \<or> ?a1 = (0::?'a1)
### Rewrite rule not in simpset:
### (1::?'a1) < ?b1 / ?a1 \<equiv>
### (0::?'a1) < ?a1 \<and> ?a1 < ?b1 \<or> ?a1 < (0::?'a1) \<and> ?b1 < ?a1
### Rewrite rule not in simpset:
### ?b1 / ?a1 < (1::?'a1) \<equiv>
### (0::?'a1) < ?a1 \<and> ?b1 < ?a1 \<or>
### ?a1 < (0::?'a1) \<and> ?a1 < ?b1 \<or> ?a1 = (0::?'a1)
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Ignoring duplicate rewrite rule:
### \<Prod>x\<in>?A1. ?y1 \<equiv> ?y1 ^ card ?A1
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?I;
###  \<And>i. i \<in> ?I \<Longrightarrow> ?A i \<in> sets ?M\<rbrakk>
### \<Longrightarrow> \<Union> (?A ` ?I) \<in> sets ?M
### Ignoring duplicate rewrite rule:
### vector_derivative (linepath ?a1 ?b1) (at ?x1) \<equiv> ?b1 - ?a1
### Ignoring duplicate rewrite rule:
### (?f1 has_contour_integral 0) (subpath ?u1 ?u1 ?g1) \<equiv> True
### Ignoring duplicate rewrite rule:
### finite ?S1 \<Longrightarrow>
### \<Sum>k\<in>?S1. if k = ?a1 then ?b1 k else (0::?'a1) \<equiv>
### if ?a1 \<in> ?S1 then ?b1 ?a1 else (0::?'a1)
### Ignoring duplicate rewrite rule:
### valid_path (reversepath ?g1) \<equiv> valid_path ?g1
### Ignoring duplicate rewrite rule:
### contour_integral (subpath ?u1 ?u1 ?g1) ?f1 \<equiv> 0
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Metis: Unused theorems: "Cauchy_Integral_Theorem.contour_integrable_subpath"
### Metis: Unused theorems: "Set.bot_set_def"
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Metis: Unused theorems: "Path_Connected.segments_subset_convex_hull_2", "Path_Connected.segments_subset_convex_hull_3", "Path_Connected.segments_subset_convex_hull_4", "Path_Connected.segments_subset_convex_hull_5", "Path_Connected.segments_subset_convex_hull_6"
### Metis: Unused theorems: "Path_Connected.segments_subset_convex_hull_1", "Path_Connected.segments_subset_convex_hull_2", "Path_Connected.segments_subset_convex_hull_4", "Path_Connected.segments_subset_convex_hull_5", "Path_Connected.segments_subset_convex_hull_6"
### Metis: Unused theorems: "Path_Connected.segments_subset_convex_hull_1", "Path_Connected.segments_subset_convex_hull_2", "Path_Connected.segments_subset_convex_hull_3", "Path_Connected.segments_subset_convex_hull_4", "Path_Connected.segments_subset_convex_hull_6"
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Metis: Unused theorems: "Path_Connected.segments_subset_convex_hull_2", "Path_Connected.segments_subset_convex_hull_3", "Path_Connected.segments_subset_convex_hull_4", "Path_Connected.segments_subset_convex_hull_5", "Path_Connected.segments_subset_convex_hull_6"
### Metis: Unused theorems: "Path_Connected.segments_subset_convex_hull_1", "Path_Connected.segments_subset_convex_hull_2", "Path_Connected.segments_subset_convex_hull_4", "Path_Connected.segments_subset_convex_hull_5", "Path_Connected.segments_subset_convex_hull_6"
### Metis: Unused theorems: "Path_Connected.segments_subset_convex_hull_1", "Path_Connected.segments_subset_convex_hull_2", "Path_Connected.segments_subset_convex_hull_3", "Path_Connected.segments_subset_convex_hull_4", "Path_Connected.segments_subset_convex_hull_6"
### Metis: Unused theorems: "Path_Connected.segments_subset_convex_hull_2", "Path_Connected.segments_subset_convex_hull_3", "Path_Connected.segments_subset_convex_hull_4", "Path_Connected.segments_subset_convex_hull_5", "Path_Connected.segments_subset_convex_hull_6"
### Metis: Unused theorems: "Path_Connected.segments_subset_convex_hull_1", "Path_Connected.segments_subset_convex_hull_2", "Path_Connected.segments_subset_convex_hull_4", "Path_Connected.segments_subset_convex_hull_5", "Path_Connected.segments_subset_convex_hull_6"
### Metis: Unused theorems: "Path_Connected.segments_subset_convex_hull_1", "Path_Connected.segments_subset_convex_hull_2", "Path_Connected.segments_subset_convex_hull_3", "Path_Connected.segments_subset_convex_hull_4", "Path_Connected.segments_subset_convex_hull_6"
### Metis: Unused theorems: "Path_Connected.segments_subset_convex_hull_2", "Path_Connected.segments_subset_convex_hull_3", "Path_Connected.segments_subset_convex_hull_4", "Path_Connected.segments_subset_convex_hull_5", "Path_Connected.segments_subset_convex_hull_6"
### Metis: Unused theorems: "Path_Connected.segments_subset_convex_hull_1", "Path_Connected.segments_subset_convex_hull_2", "Path_Connected.segments_subset_convex_hull_4", "Path_Connected.segments_subset_convex_hull_5", "Path_Connected.segments_subset_convex_hull_6"
### Metis: Unused theorems: "Path_Connected.segments_subset_convex_hull_1", "Path_Connected.segments_subset_convex_hull_2", "Path_Connected.segments_subset_convex_hull_3", "Path_Connected.segments_subset_convex_hull_4", "Path_Connected.segments_subset_convex_hull_6"
### Metis: Unused theorems: "Path_Connected.segments_subset_convex_hull_2", "Path_Connected.segments_subset_convex_hull_3", "Path_Connected.segments_subset_convex_hull_4", "Path_Connected.segments_subset_convex_hull_5", "Path_Connected.segments_subset_convex_hull_6"
### Metis: Unused theorems: "Path_Connected.segments_subset_convex_hull_1", "Path_Connected.segments_subset_convex_hull_2", "Path_Connected.segments_subset_convex_hull_4", "Path_Connected.segments_subset_convex_hull_5", "Path_Connected.segments_subset_convex_hull_6"
### Metis: Unused theorems: "Path_Connected.segments_subset_convex_hull_1", "Path_Connected.segments_subset_convex_hull_2", "Path_Connected.segments_subset_convex_hull_3", "Path_Connected.segments_subset_convex_hull_4", "Path_Connected.segments_subset_convex_hull_6"
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Metis: Unused theorems: "Extended_Real.ereal_Lim_uminus"
### Metis: Unused theorems: "Extended_Real.ereal_Lim_uminus"
### Metis: Unused theorems: "Extended_Real.ereal_minus_less_minus"
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Ignoring duplicate rewrite rule:
### \<lbrakk>?i1 \<in> Basis; ?j1 \<in> Basis\<rbrakk>
### \<Longrightarrow> (\<Sum>k\<in>Basis.
###                      if k = ?i1 then ?f1 ?i1 *\<^sub>R ?i1
###                      else ?g1 k *\<^sub>R k) \<bullet>
###                   ?j1 \<equiv>
###                   if ?j1 = ?i1 then ?f1 ?j1 else ?g1 ?j1
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 < (0::?'a1) \<equiv>
### (0::?'a1) < ?a1 \<and> ?b1 < (0::?'a1) \<or>
### ?a1 < (0::?'a1) \<and> (0::?'a1) < ?b1
### Ignoring duplicate rewrite rule:
### (0::?'a1) < ?a1 * ?b1 \<equiv>
### (0::?'a1) < ?a1 \<and> (0::?'a1) < ?b1 \<or>
### ?a1 < (0::?'a1) \<and> ?b1 < (0::?'a1)
### Ignoring duplicate rewrite rule:
### \<lbrakk>?i1 \<in> Basis; ?j1 \<in> Basis\<rbrakk>
### \<Longrightarrow> (\<Sum>k\<in>Basis.
###                      if k = ?i1 then ?f1 ?i1 *\<^sub>R ?i1
###                      else ?g1 k *\<^sub>R k) \<bullet>
###                   ?j1 \<equiv>
###                   if ?j1 = ?i1 then ?f1 ?j1 else ?g1 ?j1
### Ignoring duplicate rewrite rule:
### \<lbrakk>?i1 \<in> Basis; ?j1 \<in> Basis\<rbrakk>
### \<Longrightarrow> (\<Sum>k\<in>Basis.
###                      if k = ?i1 then ?f1 ?i1 *\<^sub>R ?i1
###                      else ?g1 k *\<^sub>R k) \<bullet>
###                   ?j1 \<equiv>
###                   if ?j1 = ?i1 then ?f1 ?j1 else ?g1 ?j1
### Ignoring duplicate rewrite rule:
### \<lbrakk>?i1 \<in> Basis; ?j1 \<in> Basis\<rbrakk>
### \<Longrightarrow> (\<Sum>k\<in>Basis.
###                      if k = ?i1 then ?f1 ?i1 *\<^sub>R ?i1
###                      else ?g1 k *\<^sub>R k) \<bullet>
###                   ?j1 \<equiv>
###                   if ?j1 = ?i1 then ?f1 ?j1 else ?g1 ?j1
### Ignoring duplicate rewrite rule:
### \<lbrakk>?i1 \<in> Basis; ?j1 \<in> Basis\<rbrakk>
### \<Longrightarrow> (\<Sum>k\<in>Basis.
###                      if k = ?i1 then ?f1 ?i1 *\<^sub>R ?i1
###                      else ?g1 k *\<^sub>R k) \<bullet>
###                   ?j1 \<equiv>
###                   if ?j1 = ?i1 then ?f1 ?j1 else ?g1 ?j1
### Ignoring duplicate rewrite rule:
### \<lbrakk>?i1 \<in> Basis; ?j1 \<in> Basis\<rbrakk>
### \<Longrightarrow> (\<Sum>k\<in>Basis.
###                      if k = ?i1 then ?f1 ?i1 *\<^sub>R ?i1
###                      else ?g1 k *\<^sub>R k) \<bullet>
###                   ?j1 \<equiv>
###                   if ?j1 = ?i1 then ?f1 ?j1 else ?g1 ?j1
### Ignoring duplicate rewrite rule:
### \<lbrakk>?i1 \<in> Basis; ?j1 \<in> Basis\<rbrakk>
### \<Longrightarrow> (\<Sum>k\<in>Basis.
###                      if k = ?i1 then ?f1 ?i1 *\<^sub>R ?i1
###                      else ?g1 k *\<^sub>R k) \<bullet>
###                   ?j1 \<equiv>
###                   if ?j1 = ?i1 then ?f1 ?j1 else ?g1 ?j1
### Ignoring duplicate rewrite rule:
### \<lbrakk>?i1 \<in> Basis; ?j1 \<in> Basis\<rbrakk>
### \<Longrightarrow> (\<Sum>k\<in>Basis.
###                      if k = ?i1 then ?f1 ?i1 *\<^sub>R ?i1
###                      else ?g1 k *\<^sub>R k) \<bullet>
###                   ?j1 \<equiv>
###                   if ?j1 = ?i1 then ?f1 ?j1 else ?g1 ?j1
### Metis: Unused theorems: "Groups.ab_semigroup_mult_class.mult.commute"
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### is_interval (cbox ?a1 ?b1) \<equiv> True
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 < (0::?'a1) \<equiv>
### (0::?'a1) < ?a1 \<and> ?b1 < (0::?'a1) \<or>
### ?a1 < (0::?'a1) \<and> (0::?'a1) < ?b1
### Ignoring duplicate rewrite rule:
### (0::?'a1) < ?a1 * ?b1 \<equiv>
### (0::?'a1) < ?a1 \<and> (0::?'a1) < ?b1 \<or>
### ?a1 < (0::?'a1) \<and> ?b1 < (0::?'a1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Rule already declared as introduction (intro)
### (\<And>x. x \<in> space ?M \<Longrightarrow> ?P x) \<Longrightarrow>
### almost_everywhere ?M ?P
### Ignoring duplicate introduction (intro)
### open {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### closed {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### closed UNIV
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Ignoring duplicate introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Ignoring duplicate introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Ignoring duplicate introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Ignoring duplicate introduction (intro)
### open {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### closed {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### closed UNIV
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Ignoring duplicate introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Ignoring duplicate introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Ignoring duplicate introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Undeclared classical rule
### (?a \<le> ?b / numeral ?w) = (?a * numeral ?w \<le> ?b)
### Undeclared classical rule
### (?a \<le> ?b / - numeral ?w) = (?b \<le> ?a * - numeral ?w)
### Undeclared classical rule
### (?b / numeral ?w \<le> ?a) = (?b \<le> ?a * numeral ?w)
### Undeclared classical rule
### (?b / - numeral ?w \<le> ?a) = (?a * - numeral ?w \<le> ?b)
### Undeclared classical rule
### (?a < ?b / numeral ?w) = (?a * numeral ?w < ?b)
### Undeclared classical rule
### (?a < ?b / - numeral ?w) = (?b < ?a * - numeral ?w)
### Undeclared classical rule
### (?b / numeral ?w < ?a) = (?b < ?a * numeral ?w)
### Undeclared classical rule
### (?b / - numeral ?w < ?a) = (?a * - numeral ?w < ?b)
### Undeclared classical rule
### (?a = ?b / numeral ?w) =
### (if numeral ?w \<noteq> (0::?'a) then ?a * numeral ?w = ?b
###  else ?a = (0::?'a))
### Undeclared classical rule
### (?a = ?b / - numeral ?w) =
### (if - numeral ?w \<noteq> (0::?'a) then ?a * - numeral ?w = ?b
###  else ?a = (0::?'a))
### Undeclared classical rule
### (?b / numeral ?w = ?a) =
### (if numeral ?w \<noteq> (0::?'a) then ?b = ?a * numeral ?w
###  else ?a = (0::?'a))
### Undeclared classical rule
### (?b / - numeral ?w = ?a) =
### (if - numeral ?w \<noteq> (0::?'a) then ?b = ?a * - numeral ?w
###  else ?a = (0::?'a))
### Undeclared classical rule
### (numeral ?w \<le> ?b / ?c) =
### (if (0::?'a) < ?c then numeral ?w * ?c \<le> ?b
###  else if ?c < (0::?'a) then ?b \<le> numeral ?w * ?c
###       else numeral ?w \<le> (0::?'a))
### Undeclared classical rule
### (- numeral ?w \<le> ?b / ?c) =
### (if (0::?'a) < ?c then - numeral ?w * ?c \<le> ?b
###  else if ?c < (0::?'a) then ?b \<le> - numeral ?w * ?c
###       else - numeral ?w \<le> (0::?'a))
### Undeclared classical rule
### (?b / ?c \<le> numeral ?w) =
### (if (0::?'a) < ?c then ?b \<le> numeral ?w * ?c
###  else if ?c < (0::?'a) then numeral ?w * ?c \<le> ?b
###       else (0::?'a) \<le> numeral ?w)
### Undeclared classical rule
### (?b / ?c \<le> - numeral ?w) =
### (if (0::?'a) < ?c then ?b \<le> - numeral ?w * ?c
###  else if ?c < (0::?'a) then - numeral ?w * ?c \<le> ?b
###       else (0::?'a) \<le> - numeral ?w)
### Undeclared classical rule
### (numeral ?w < ?b / ?c) =
### (if (0::?'a) < ?c then numeral ?w * ?c < ?b
###  else if ?c < (0::?'a) then ?b < numeral ?w * ?c else numeral ?w < (0::?'a))
### Undeclared classical rule
### (- numeral ?w < ?b / ?c) =
### (if (0::?'a) < ?c then - numeral ?w * ?c < ?b
###  else if ?c < (0::?'a) then ?b < - numeral ?w * ?c
###       else - numeral ?w < (0::?'a))
### Undeclared classical rule
### (?b / ?c < numeral ?w) =
### (if (0::?'a) < ?c then ?b < numeral ?w * ?c
###  else if ?c < (0::?'a) then numeral ?w * ?c < ?b else (0::?'a) < numeral ?w)
### Undeclared classical rule
### (?b / ?c < - numeral ?w) =
### (if (0::?'a) < ?c then ?b < - numeral ?w * ?c
###  else if ?c < (0::?'a) then - numeral ?w * ?c < ?b
###       else (0::?'a) < - numeral ?w)
### Undeclared classical rule
### (numeral ?w = ?b / ?c) =
### (if ?c \<noteq> (0::?'a) then numeral ?w * ?c = ?b
###  else numeral ?w = (0::?'a))
### Undeclared classical rule
### (- numeral ?w = ?b / ?c) =
### (if ?c \<noteq> (0::?'a) then - numeral ?w * ?c = ?b
###  else - numeral ?w = (0::?'a))
### Undeclared classical rule
### (?b / ?c = numeral ?w) =
### (if ?c \<noteq> (0::?'a) then ?b = numeral ?w * ?c
###  else numeral ?w = (0::?'a))
### Undeclared classical rule
### (?b / ?c = - numeral ?w) =
### (if ?c \<noteq> (0::?'a) then ?b = - numeral ?w * ?c
###  else - numeral ?w = (0::?'a))
### Undeclared classical rule
### ((1::?'a) \<le> ?b / ?a) =
### ((0::?'a) < ?a \<and> ?a \<le> ?b \<or> ?a < (0::?'a) \<and> ?b \<le> ?a)
### Undeclared classical rule
### (?b / ?a \<le> (1::?'a)) =
### ((0::?'a) < ?a \<and> ?b \<le> ?a \<or>
###  ?a < (0::?'a) \<and> ?a \<le> ?b \<or> ?a = (0::?'a))
### Undeclared classical rule
### ((1::?'a) < ?b / ?a) =
### ((0::?'a) < ?a \<and> ?a < ?b \<or> ?a < (0::?'a) \<and> ?b < ?a)
### Undeclared classical rule
### (?b / ?a < (1::?'a)) =
### ((0::?'a) < ?a \<and> ?b < ?a \<or>
###  ?a < (0::?'a) \<and> ?a < ?b \<or> ?a = (0::?'a))
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 < (0::?'a1) \<equiv>
### (0::?'a1) < ?a1 \<and> ?b1 < (0::?'a1) \<or>
### ?a1 < (0::?'a1) \<and> (0::?'a1) < ?b1
### Ignoring duplicate rewrite rule:
### (*) ?c1 analytic_on ?S1 \<equiv> True
### Ignoring duplicate rewrite rule:
### deriv ((*) ?y2) \<equiv> \<lambda>z. ?y2
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### (\<lambda>z. ?c1) holomorphic_on ?s1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (\<lambda>z. ?c1) holomorphic_on ?s1 \<equiv> True
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Rule already declared as elimination (elim)
### \<lbrakk>?f holomorphic_on ?s; ?t \<subseteq> ?s\<rbrakk>
### \<Longrightarrow> ?f holomorphic_on ?t
### Ignoring duplicate rewrite rule:
### ((\<lambda>x. x) has_derivative (\<lambda>x. x)) ?F1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (id has_derivative id) (at ?a1) \<equiv> True
### Ignoring duplicate rewrite rule:
### ((\<lambda>x. ?c1) has_derivative (\<lambda>x. 0::?'b1)) ?F1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (?g1 has_derivative ?g'1) ?F1 \<Longrightarrow>
### ((\<lambda>x. of_real (?g1 x)) has_derivative
###  (\<lambda>x. of_real (?g'1 x)))
###  ?F1 \<equiv>
### True
### Ignoring duplicate rewrite rule:
### \<lbrakk>(?f1 has_derivative ?f'1) ?F1;
###  (?g1 has_derivative ?g'1) ?F1\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?f1 x + ?g1 x) has_derivative
###                    (\<lambda>x. ?f'1 x + ?g'1 x))
###                    ?F1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### (\<And>i.
###     i \<in> ?I1 \<Longrightarrow>
###     (?f1 i has_derivative ?f'1 i) ?F1) \<Longrightarrow>
### ((\<lambda>x. \<Sum>i\<in>?I1. ?f1 i x) has_derivative
###  (\<lambda>x. \<Sum>i\<in>?I1. ?f'1 i x))
###  ?F1 \<equiv>
### True
### Ignoring duplicate rewrite rule:
### (?f1 has_derivative ?f'1) ?F1 \<Longrightarrow>
### ((\<lambda>x. - ?f1 x) has_derivative (\<lambda>x. - ?f'1 x)) ?F1 \<equiv>
### True
### Ignoring duplicate rewrite rule:
### \<lbrakk>(?f1 has_derivative ?f'1) ?F1;
###  (?g1 has_derivative ?g'1) ?F1\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?f1 x - ?g1 x) has_derivative
###                    (\<lambda>x. ?f'1 x - ?g'1 x))
###                    ?F1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### \<lbrakk>(?f1 has_derivative ?f'1) (at ?x1 within ?s1);
###  (?g1 has_derivative ?g'1) (at ?x1 within ?s1)\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?f1 x * ?g1 x) has_derivative
###                    (\<lambda>h. ?f1 ?x1 * ?g'1 h + ?f'1 h * ?g1 ?x1))
###                    (at ?x1 within ?s1) \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### \<lbrakk>(?f1 has_derivative ?f'1) (at ?x1 within ?s1);
###  (?g1 has_derivative ?g'1) (at ?x1 within ?s1)\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?f1 x *\<^sub>R ?g1 x) has_derivative
###                    (\<lambda>h.
###                        ?f1 ?x1 *\<^sub>R ?g'1 h + ?f'1 h *\<^sub>R ?g1 ?x1))
###                    (at ?x1 within ?s1) \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### (\<And>i.
###     i \<in> ?I1 \<Longrightarrow>
###     (?f1 i has_derivative ?f'1 i) (at ?x1 within ?S1)) \<Longrightarrow>
### ((\<lambda>x. \<Prod>i\<in>?I1. ?f1 i x) has_derivative
###  (\<lambda>y.
###      \<Sum>i\<in>?I1. ?f'1 i y * (\<Prod>j\<in>?I1 - {i}. ?f1 j ?x1)))
###  (at ?x1 within ?S1) \<equiv>
### True
### Ignoring duplicate rewrite rule:
### (?f1 has_derivative ?f'1) (at ?x1 within ?S1) \<Longrightarrow>
### ((\<lambda>x. ?f1 x ^ ?n1) has_derivative
###  (\<lambda>y. of_nat ?n1 * ?f'1 y * ?f1 ?x1 ^ (?n1 - 1)))
###  (at ?x1 within ?S1) \<equiv>
### True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 ?x1 \<noteq> (0::?'a1);
###  (?f1 has_derivative ?f'1) (at ?x1 within ?S1)\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. inverse (?f1 x)) has_derivative
###                    (\<lambda>h.
###                        - (inverse (?f1 ?x1) * ?f'1 h * inverse (?f1 ?x1))))
###                    (at ?x1 within ?S1) \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### \<lbrakk>(?f1 has_derivative ?f'1) (at ?x1 within ?S1);
###  (?g1 has_derivative ?g'1) (at ?x1 within ?S1);
###  ?g1 ?x1 \<noteq> (0::?'a1)\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?f1 x / ?g1 x) has_derivative
###                    (\<lambda>h.
###                        - ?f1 ?x1 *
###                        (inverse (?g1 ?x1) * ?g'1 h * inverse (?g1 ?x1)) +
###                        ?f'1 h / ?g1 ?x1))
###                    (at ?x1 within ?S1) \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### (\<lambda>x. x) differentiable ?F1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (\<lambda>z. ?a1) differentiable ?F1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 differentiable ?F1; ?g1 differentiable ?F1\<rbrakk>
### \<Longrightarrow> (\<lambda>x. ?f1 x + ?g1 x) differentiable ?F1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### \<lbrakk>finite ?s1; \<forall>a\<in>?s1. ?f1 a differentiable ?net1\<rbrakk>
### \<Longrightarrow> (\<lambda>x. \<Sum>a\<in>?s1. ?f1 a x) differentiable
###                   ?net1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### ?f1 differentiable ?F1 \<Longrightarrow>
### (\<lambda>x. - ?f1 x) differentiable ?F1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 differentiable ?F1; ?g1 differentiable ?F1\<rbrakk>
### \<Longrightarrow> (\<lambda>x. ?f1 x - ?g1 x) differentiable ?F1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 differentiable at ?x1 within ?s1;
###  ?g1 differentiable at ?x1 within ?s1\<rbrakk>
### \<Longrightarrow> (\<lambda>x. ?f1 x * ?g1 x) differentiable at ?x1
###                   within ?s1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 differentiable at ?x1 within ?s1;
###  ?f1 ?x1 \<noteq> (0::?'b1)\<rbrakk>
### \<Longrightarrow> (\<lambda>x. inverse (?f1 x)) differentiable at ?x1
###                   within ?s1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 differentiable at ?x1 within ?s1;
###  ?g1 differentiable at ?x1 within ?s1; ?g1 ?x1 \<noteq> (0::?'b1)\<rbrakk>
### \<Longrightarrow> (\<lambda>x. ?f1 x / ?g1 x) differentiable at ?x1
###                   within ?s1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### ?f1 differentiable at ?x1 within ?s1 \<Longrightarrow>
### (\<lambda>x. ?f1 x ^ ?n1) differentiable at ?x1 within ?s1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 differentiable at ?x1 within ?s1;
###  ?g1 differentiable at ?x1 within ?s1\<rbrakk>
### \<Longrightarrow> (\<lambda>x. ?f1 x *\<^sub>R ?g1 x) differentiable at ?x1
###                   within ?s1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### ((\<lambda>x. ?c1) has_vector_derivative (0::?'a1)) ?net1 \<equiv> True
### Ignoring duplicate rewrite rule:
### ((\<lambda>x. x) has_vector_derivative 1) ?net1 \<equiv> True
### Ignoring duplicate rewrite rule:
### ((\<lambda>x. ?k1) has_field_derivative (0::?'a1)) ?F1 \<equiv> True
### Ignoring duplicate rewrite rule:
### ((\<lambda>x. x) has_field_derivative (1::?'a1)) ?F1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (?g1 has_derivative ?g'1) ?F1 \<Longrightarrow>
### ((\<lambda>x. cnj (?g1 x)) has_derivative (\<lambda>x. cnj (?g'1 x)))
###  ?F1 \<equiv>
### True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 differentiable at ?x1 within ?s1;
###  ?g1 differentiable at ?x1 within ?s1\<rbrakk>
### \<Longrightarrow> (\<lambda>x. (?f1 x, ?g1 x)) differentiable at ?x1
###                   within ?s1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### (\<lambda>x. x) differentiable_on ?S1 \<equiv> True
### Ignoring duplicate rewrite rule:
### id differentiable_on ?S1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (\<lambda>z. ?c1) differentiable_on ?S1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 differentiable_on ?S1; ?g1 differentiable_on ?S1\<rbrakk>
### \<Longrightarrow> (\<lambda>z. ?f1 z * ?g1 z) differentiable_on ?S1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### ?f1 differentiable_on ?S1 \<Longrightarrow>
### (\<lambda>z. - ?f1 z) differentiable_on ?S1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 differentiable_on ?S1; ?g1 differentiable_on ?S1\<rbrakk>
### \<Longrightarrow> (\<lambda>z. ?f1 z + ?g1 z) differentiable_on ?S1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 differentiable_on ?S1; ?g1 differentiable_on ?S1\<rbrakk>
### \<Longrightarrow> (\<lambda>z. ?f1 z - ?g1 z) differentiable_on ?S1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 differentiable_on ?S1;
###  \<And>x. x \<in> ?S1 \<Longrightarrow> ?f1 x \<noteq> (0::?'b1)\<rbrakk>
### \<Longrightarrow> (\<lambda>x. inverse (?f1 x)) differentiable_on
###                   ?S1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 differentiable_on ?S1; ?g1 differentiable_on ?S1\<rbrakk>
### \<Longrightarrow> (\<lambda>x. ?f1 x *\<^sub>R ?g1 x) differentiable_on
###                   ?S1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### ((\<lambda>x. (norm x)\<^sup>2) has_derivative
###  (\<lambda>x. 2 *\<^sub>R (?a1 \<bullet> x)))
###  (at ?a1) \<equiv>
### True
### Ignoring duplicate rewrite rule:
### (\<lambda>x. (norm x)\<^sup>2) differentiable at ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (\<lambda>x. (norm x)\<^sup>2) differentiable_on ?S1 \<equiv> True
### Ignoring duplicate rewrite rule:
### ?a1 \<noteq> (0::?'a1) \<Longrightarrow>
### norm differentiable at ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (0::?'a1) \<notin> ?S1 \<Longrightarrow>
### norm differentiable_on ?S1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (*) ?c1 field_differentiable ?F1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (\<lambda>z. ?c1) field_differentiable ?F1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (\<lambda>z. z) field_differentiable ?F1 \<equiv> True
### Ignoring duplicate rewrite rule:
### id field_differentiable ?F1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (+) ?c1 field_differentiable ?F1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (\<lambda>x. x) C1_differentiable_on ?S1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (\<lambda>z. ?a1) C1_differentiable_on ?S1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 C1_differentiable_on ?S1; ?g1 C1_differentiable_on ?S1\<rbrakk>
### \<Longrightarrow> (\<lambda>x. ?f1 x + ?g1 x) C1_differentiable_on
###                   ?S1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### ?f1 C1_differentiable_on ?S1 \<Longrightarrow>
### (\<lambda>x. - ?f1 x) C1_differentiable_on ?S1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 C1_differentiable_on ?S1; ?g1 C1_differentiable_on ?S1\<rbrakk>
### \<Longrightarrow> (\<lambda>x. ?f1 x - ?g1 x) C1_differentiable_on
###                   ?S1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 C1_differentiable_on ?S1; ?g1 C1_differentiable_on ?S1\<rbrakk>
### \<Longrightarrow> (\<lambda>x. ?f1 x * ?g1 x) C1_differentiable_on
###                   ?S1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 C1_differentiable_on ?S1; ?g1 C1_differentiable_on ?S1\<rbrakk>
### \<Longrightarrow> (\<lambda>x. ?f1 x *\<^sub>R ?g1 x) C1_differentiable_on
###                   ?S1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### linear ((*) ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### open {} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed UNIV \<equiv> True
### Ignoring duplicate rewrite rule:
### closed ?S1 \<Longrightarrow> closed (insert ?a1 ?S1) \<equiv> True
### Ignoring duplicate rewrite rule:
### open {?a1<..} \<equiv> True
### Ignoring duplicate rewrite rule:
### open {..<?a1} \<equiv> True
### Ignoring duplicate rewrite rule:
### open {?a1<..<?b1} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {..?a1} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {?a1..} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {?a1..?b1} \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 id \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous bot ?f1 \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous (at ?x1 within ?S1) (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous (at ?x1 within ?S1) id \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous ?F1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; isCont ?g1 ?a1; ?g1 ?a1 \<noteq> (0::?'b1)\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. ?f1 x / ?g1 x) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; isCont ?g1 ?a1; 0 < ?f1 ?a1; ?f1 ?a1 \<noteq> 1;
###  0 < ?g1 ?a1\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. log (?f1 x) (?g1 x)) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; isCont ?g1 ?a1; ?f1 ?a1 \<noteq> 0\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. ?f1 x powr ?g1 x) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; cos (?f1 ?a1) \<noteq> (0::?'a1)\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. tan (?f1 x)) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; sin (?f1 ?a1) \<noteq> (0::?'a1)\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. cot (?f1 x)) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous ?F1 ?g1 \<Longrightarrow>
### continuous ?F1 (\<lambda>x. cnj (?g1 x)) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 ?g1 \<Longrightarrow>
### continuous_on ?s1 (\<lambda>x. cnj (?g1 x)) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_map ?X1 ?X1 id \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_map ?X1 ?X1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?z1;
###  ?f1 ?z1 \<notin> \<real>\<^sub>\<le>\<^sub>0\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. Ln (?f1 x)) ?z1 \<equiv> True
### Ignoring duplicate rewrite rule:
### ((\<lambda>x. x) has_derivative (\<lambda>x. x)) ?F1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (id has_derivative id) (at ?a1) \<equiv> True
### Ignoring duplicate rewrite rule:
### ((\<lambda>x. ?c1) has_derivative (\<lambda>x. 0::?'b1)) ?F1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (?g1 has_derivative ?g'1) ?F1 \<Longrightarrow>
### ((\<lambda>x. of_real (?g1 x)) has_derivative
###  (\<lambda>x. of_real (?g'1 x)))
###  ?F1 \<equiv>
### True
### Ignoring duplicate rewrite rule:
### \<lbrakk>(?f1 has_derivative ?f'1) ?F1;
###  (?g1 has_derivative ?g'1) ?F1\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?f1 x + ?g1 x) has_derivative
###                    (\<lambda>x. ?f'1 x + ?g'1 x))
###                    ?F1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### (\<And>i.
###     i \<in> ?I1 \<Longrightarrow>
###     (?f1 i has_derivative ?f'1 i) ?F1) \<Longrightarrow>
### ((\<lambda>x. \<Sum>i\<in>?I1. ?f1 i x) has_derivative
###  (\<lambda>x. \<Sum>i\<in>?I1. ?f'1 i x))
###  ?F1 \<equiv>
### True
### Ignoring duplicate rewrite rule:
### (?f1 has_derivative ?f'1) ?F1 \<Longrightarrow>
### ((\<lambda>x. - ?f1 x) has_derivative (\<lambda>x. - ?f'1 x)) ?F1 \<equiv>
### True
### Ignoring duplicate rewrite rule:
### \<lbrakk>(?f1 has_derivative ?f'1) ?F1;
###  (?g1 has_derivative ?g'1) ?F1\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?f1 x - ?g1 x) has_derivative
###                    (\<lambda>x. ?f'1 x - ?g'1 x))
###                    ?F1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### \<lbrakk>(?f1 has_derivative ?f'1) (at ?x1 within ?s1);
###  (?g1 has_derivative ?g'1) (at ?x1 within ?s1)\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?f1 x * ?g1 x) has_derivative
###                    (\<lambda>h. ?f1 ?x1 * ?g'1 h + ?f'1 h * ?g1 ?x1))
###                    (at ?x1 within ?s1) \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### \<lbrakk>(?f1 has_derivative ?f'1) (at ?x1 within ?s1);
###  (?g1 has_derivative ?g'1) (at ?x1 within ?s1)\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?f1 x *\<^sub>R ?g1 x) has_derivative
###                    (\<lambda>h.
###                        ?f1 ?x1 *\<^sub>R ?g'1 h + ?f'1 h *\<^sub>R ?g1 ?x1))
###                    (at ?x1 within ?s1) \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### (\<And>i.
###     i \<in> ?I1 \<Longrightarrow>
###     (?f1 i has_derivative ?f'1 i) (at ?x1 within ?S1)) \<Longrightarrow>
### ((\<lambda>x. \<Prod>i\<in>?I1. ?f1 i x) has_derivative
###  (\<lambda>y.
###      \<Sum>i\<in>?I1. ?f'1 i y * (\<Prod>j\<in>?I1 - {i}. ?f1 j ?x1)))
###  (at ?x1 within ?S1) \<equiv>
### True
### Ignoring duplicate rewrite rule:
### (?f1 has_derivative ?f'1) (at ?x1 within ?S1) \<Longrightarrow>
### ((\<lambda>x. ?f1 x ^ ?n1) has_derivative
###  (\<lambda>y. of_nat ?n1 * ?f'1 y * ?f1 ?x1 ^ (?n1 - 1)))
###  (at ?x1 within ?S1) \<equiv>
### True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 ?x1 \<noteq> (0::?'a1);
###  (?f1 has_derivative ?f'1) (at ?x1 within ?S1)\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. inverse (?f1 x)) has_derivative
###                    (\<lambda>h.
###                        - (inverse (?f1 ?x1) * ?f'1 h * inverse (?f1 ?x1))))
###                    (at ?x1 within ?S1) \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### \<lbrakk>(?f1 has_derivative ?f'1) (at ?x1 within ?S1);
###  (?g1 has_derivative ?g'1) (at ?x1 within ?S1);
###  ?g1 ?x1 \<noteq> (0::?'a1)\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?f1 x / ?g1 x) has_derivative
###                    (\<lambda>h.
###                        - ?f1 ?x1 *
###                        (inverse (?g1 ?x1) * ?g'1 h * inverse (?g1 ?x1)) +
###                        ?f'1 h / ?g1 ?x1))
###                    (at ?x1 within ?S1) \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### (\<lambda>x. x) differentiable ?F1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (\<lambda>z. ?a1) differentiable ?F1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 differentiable ?F1; ?g1 differentiable ?F1\<rbrakk>
### \<Longrightarrow> (\<lambda>x. ?f1 x + ?g1 x) differentiable ?F1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### \<lbrakk>finite ?s1; \<forall>a\<in>?s1. ?f1 a differentiable ?net1\<rbrakk>
### \<Longrightarrow> (\<lambda>x. \<Sum>a\<in>?s1. ?f1 a x) differentiable
###                   ?net1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### ?f1 differentiable ?F1 \<Longrightarrow>
### (\<lambda>x. - ?f1 x) differentiable ?F1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 differentiable ?F1; ?g1 differentiable ?F1\<rbrakk>
### \<Longrightarrow> (\<lambda>x. ?f1 x - ?g1 x) differentiable ?F1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 differentiable at ?x1 within ?s1;
###  ?g1 differentiable at ?x1 within ?s1\<rbrakk>
### \<Longrightarrow> (\<lambda>x. ?f1 x * ?g1 x) differentiable at ?x1
###                   within ?s1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 differentiable at ?x1 within ?s1;
###  ?f1 ?x1 \<noteq> (0::?'b1)\<rbrakk>
### \<Longrightarrow> (\<lambda>x. inverse (?f1 x)) differentiable at ?x1
###                   within ?s1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 differentiable at ?x1 within ?s1;
###  ?g1 differentiable at ?x1 within ?s1; ?g1 ?x1 \<noteq> (0::?'b1)\<rbrakk>
### \<Longrightarrow> (\<lambda>x. ?f1 x / ?g1 x) differentiable at ?x1
###                   within ?s1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### ?f1 differentiable at ?x1 within ?s1 \<Longrightarrow>
### (\<lambda>x. ?f1 x ^ ?n1) differentiable at ?x1 within ?s1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 differentiable at ?x1 within ?s1;
###  ?g1 differentiable at ?x1 within ?s1\<rbrakk>
### \<Longrightarrow> (\<lambda>x. ?f1 x *\<^sub>R ?g1 x) differentiable at ?x1
###                   within ?s1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### ((\<lambda>x. ?c1) has_vector_derivative (0::?'a1)) ?net1 \<equiv> True
### Ignoring duplicate rewrite rule:
### ((\<lambda>x. x) has_vector_derivative 1) ?net1 \<equiv> True
### Ignoring duplicate rewrite rule:
### ((\<lambda>x. ?k1) has_field_derivative (0::?'a1)) ?F1 \<equiv> True
### Ignoring duplicate rewrite rule:
### ((\<lambda>x. x) has_field_derivative (1::?'a1)) ?F1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (?g1 has_derivative ?g'1) ?F1 \<Longrightarrow>
### ((\<lambda>x. cnj (?g1 x)) has_derivative (\<lambda>x. cnj (?g'1 x)))
###  ?F1 \<equiv>
### True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 differentiable at ?x1 within ?s1;
###  ?g1 differentiable at ?x1 within ?s1\<rbrakk>
### \<Longrightarrow> (\<lambda>x. (?f1 x, ?g1 x)) differentiable at ?x1
###                   within ?s1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### (\<lambda>x. x) differentiable_on ?S1 \<equiv> True
### Ignoring duplicate rewrite rule:
### id differentiable_on ?S1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (\<lambda>z. ?c1) differentiable_on ?S1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 differentiable_on ?S1; ?g1 differentiable_on ?S1\<rbrakk>
### \<Longrightarrow> (\<lambda>z. ?f1 z * ?g1 z) differentiable_on ?S1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### ?f1 differentiable_on ?S1 \<Longrightarrow>
### (\<lambda>z. - ?f1 z) differentiable_on ?S1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 differentiable_on ?S1; ?g1 differentiable_on ?S1\<rbrakk>
### \<Longrightarrow> (\<lambda>z. ?f1 z + ?g1 z) differentiable_on ?S1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 differentiable_on ?S1; ?g1 differentiable_on ?S1\<rbrakk>
### \<Longrightarrow> (\<lambda>z. ?f1 z - ?g1 z) differentiable_on ?S1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 differentiable_on ?S1;
###  \<And>x. x \<in> ?S1 \<Longrightarrow> ?f1 x \<noteq> (0::?'b1)\<rbrakk>
### \<Longrightarrow> (\<lambda>x. inverse (?f1 x)) differentiable_on
###                   ?S1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 differentiable_on ?S1; ?g1 differentiable_on ?S1\<rbrakk>
### \<Longrightarrow> (\<lambda>x. ?f1 x *\<^sub>R ?g1 x) differentiable_on
###                   ?S1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### ((\<lambda>x. (norm x)\<^sup>2) has_derivative
###  (\<lambda>x. 2 *\<^sub>R (?a1 \<bullet> x)))
###  (at ?a1) \<equiv>
### True
### Ignoring duplicate rewrite rule:
### (\<lambda>x. (norm x)\<^sup>2) differentiable at ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (\<lambda>x. (norm x)\<^sup>2) differentiable_on ?S1 \<equiv> True
### Ignoring duplicate rewrite rule:
### ?a1 \<noteq> (0::?'a1) \<Longrightarrow>
### norm differentiable at ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (0::?'a1) \<notin> ?S1 \<Longrightarrow>
### norm differentiable_on ?S1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (*) ?c1 field_differentiable ?F1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (\<lambda>z. ?c1) field_differentiable ?F1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (\<lambda>z. z) field_differentiable ?F1 \<equiv> True
### Ignoring duplicate rewrite rule:
### id field_differentiable ?F1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (+) ?c1 field_differentiable ?F1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (\<lambda>x. x) C1_differentiable_on ?S1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (\<lambda>z. ?a1) C1_differentiable_on ?S1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 C1_differentiable_on ?S1; ?g1 C1_differentiable_on ?S1\<rbrakk>
### \<Longrightarrow> (\<lambda>x. ?f1 x + ?g1 x) C1_differentiable_on
###                   ?S1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### ?f1 C1_differentiable_on ?S1 \<Longrightarrow>
### (\<lambda>x. - ?f1 x) C1_differentiable_on ?S1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 C1_differentiable_on ?S1; ?g1 C1_differentiable_on ?S1\<rbrakk>
### \<Longrightarrow> (\<lambda>x. ?f1 x - ?g1 x) C1_differentiable_on
###                   ?S1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 C1_differentiable_on ?S1; ?g1 C1_differentiable_on ?S1\<rbrakk>
### \<Longrightarrow> (\<lambda>x. ?f1 x * ?g1 x) C1_differentiable_on
###                   ?S1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### \<lbrakk>?f1 C1_differentiable_on ?S1; ?g1 C1_differentiable_on ?S1\<rbrakk>
### \<Longrightarrow> (\<lambda>x. ?f1 x *\<^sub>R ?g1 x) C1_differentiable_on
###                   ?S1 \<equiv>
###                   True
### Ignoring duplicate rewrite rule:
### homotopic_with ?P1 ?X1 ?Y1 ?f1 ?f1 \<equiv>
### continuous_map ?X1 ?Y1 ?f1 \<and> ?P1 ?f1
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### open {} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed UNIV \<equiv> True
### Ignoring duplicate rewrite rule:
### closed ?S1 \<Longrightarrow> closed (insert ?a1 ?S1) \<equiv> True
### Ignoring duplicate rewrite rule:
### open {?a1<..} \<equiv> True
### Ignoring duplicate rewrite rule:
### open {..<?a1} \<equiv> True
### Ignoring duplicate rewrite rule:
### open {?a1<..<?b1} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {..?a1} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {?a1..} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {?a1..?b1} \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 id \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous bot ?f1 \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous (at ?x1 within ?S1) (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous (at ?x1 within ?S1) id \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous ?F1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; isCont ?g1 ?a1; ?g1 ?a1 \<noteq> (0::?'b1)\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. ?f1 x / ?g1 x) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; isCont ?g1 ?a1; 0 < ?f1 ?a1; ?f1 ?a1 \<noteq> 1;
###  0 < ?g1 ?a1\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. log (?f1 x) (?g1 x)) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; isCont ?g1 ?a1; ?f1 ?a1 \<noteq> 0\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. ?f1 x powr ?g1 x) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; cos (?f1 ?a1) \<noteq> (0::?'a1)\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. tan (?f1 x)) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; sin (?f1 ?a1) \<noteq> (0::?'a1)\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. cot (?f1 x)) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous ?F1 ?g1 \<Longrightarrow>
### continuous ?F1 (\<lambda>x. cnj (?g1 x)) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 ?g1 \<Longrightarrow>
### continuous_on ?s1 (\<lambda>x. cnj (?g1 x)) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_map ?X1 ?X1 id \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_map ?X1 ?X1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?z1;
###  ?f1 ?z1 \<notin> \<real>\<^sub>\<le>\<^sub>0\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. Ln (?f1 x)) ?z1 \<equiv> True
### Ignoring duplicate rewrite rule:
### (+) ?b1 ` ball ?a1 ?r1 \<equiv> ball (?a1 + ?b1) ?r1
### Ignoring duplicate rewrite rule:
### continuous_on {?x1} ?f1 \<equiv> True
### Metis: Unused theorems: "Real_Vector_Spaces.real_normed_vector_class.norm_minus_commute"
### Rewrite rule not in simpset:
### numeral ?w1 \<le> ?b1 / ?c1 \<equiv>
### if (0::?'a1) < ?c1 then numeral ?w1 * ?c1 \<le> ?b1
### else if ?c1 < (0::?'a1) then ?b1 \<le> numeral ?w1 * ?c1
###      else numeral ?w1 \<le> (0::?'a1)
### Rewrite rule not in simpset:
### - numeral ?w1 \<le> ?b1 / ?c1 \<equiv>
### if (0::?'a1) < ?c1 then - numeral ?w1 * ?c1 \<le> ?b1
### else if ?c1 < (0::?'a1) then ?b1 \<le> - numeral ?w1 * ?c1
###      else - numeral ?w1 \<le> (0::?'a1)
### Rewrite rule not in simpset:
### ?b1 / ?c1 \<le> numeral ?w1 \<equiv>
### if (0::?'a1) < ?c1 then ?b1 \<le> numeral ?w1 * ?c1
### else if ?c1 < (0::?'a1) then numeral ?w1 * ?c1 \<le> ?b1
###      else (0::?'a1) \<le> numeral ?w1
### Rewrite rule not in simpset:
### ?b1 / ?c1 \<le> - numeral ?w1 \<equiv>
### if (0::?'a1) < ?c1 then ?b1 \<le> - numeral ?w1 * ?c1
### else if ?c1 < (0::?'a1) then - numeral ?w1 * ?c1 \<le> ?b1
###      else (0::?'a1) \<le> - numeral ?w1
### Rewrite rule not in simpset:
### numeral ?w1 < ?b1 / ?c1 \<equiv>
### if (0::?'a1) < ?c1 then numeral ?w1 * ?c1 < ?b1
### else if ?c1 < (0::?'a1) then ?b1 < numeral ?w1 * ?c1
###      else numeral ?w1 < (0::?'a1)
### Rewrite rule not in simpset:
### - numeral ?w1 < ?b1 / ?c1 \<equiv>
### if (0::?'a1) < ?c1 then - numeral ?w1 * ?c1 < ?b1
### else if ?c1 < (0::?'a1) then ?b1 < - numeral ?w1 * ?c1
###      else - numeral ?w1 < (0::?'a1)
### Rewrite rule not in simpset:
### ?b1 / ?c1 < numeral ?w1 \<equiv>
### if (0::?'a1) < ?c1 then ?b1 < numeral ?w1 * ?c1
### else if ?c1 < (0::?'a1) then numeral ?w1 * ?c1 < ?b1
###      else (0::?'a1) < numeral ?w1
### Rewrite rule not in simpset:
### ?b1 / ?c1 < - numeral ?w1 \<equiv>
### if (0::?'a1) < ?c1 then ?b1 < - numeral ?w1 * ?c1
### else if ?c1 < (0::?'a1) then - numeral ?w1 * ?c1 < ?b1
###      else (0::?'a1) < - numeral ?w1
### Rewrite rule not in simpset:
### numeral ?w1 = ?b1 / ?c1 \<equiv>
### if ?c1 \<noteq> (0::?'a1) then numeral ?w1 * ?c1 = ?b1
### else numeral ?w1 = (0::?'a1)
### Rewrite rule not in simpset:
### - numeral ?w1 = ?b1 / ?c1 \<equiv>
### if ?c1 \<noteq> (0::?'a1) then - numeral ?w1 * ?c1 = ?b1
### else - numeral ?w1 = (0::?'a1)
### Rewrite rule not in simpset:
### ?b1 / ?c1 = numeral ?w1 \<equiv>
### if ?c1 \<noteq> (0::?'a1) then ?b1 = numeral ?w1 * ?c1
### else numeral ?w1 = (0::?'a1)
### Rewrite rule not in simpset:
### ?b1 / ?c1 = - numeral ?w1 \<equiv>
### if ?c1 \<noteq> (0::?'a1) then ?b1 = - numeral ?w1 * ?c1
### else - numeral ?w1 = (0::?'a1)
### Rewrite rule not in simpset:
### (1::?'a1) \<le> ?b1 / ?a1 \<equiv>
### (0::?'a1) < ?a1 \<and> ?a1 \<le> ?b1 \<or>
### ?a1 < (0::?'a1) \<and> ?b1 \<le> ?a1
### Rewrite rule not in simpset:
### ?b1 / ?a1 \<le> (1::?'a1) \<equiv>
### (0::?'a1) < ?a1 \<and> ?b1 \<le> ?a1 \<or>
### ?a1 < (0::?'a1) \<and> ?a1 \<le> ?b1 \<or> ?a1 = (0::?'a1)
### Rewrite rule not in simpset:
### (1::?'a1) < ?b1 / ?a1 \<equiv>
### (0::?'a1) < ?a1 \<and> ?a1 < ?b1 \<or> ?a1 < (0::?'a1) \<and> ?b1 < ?a1
### Rewrite rule not in simpset:
### ?b1 / ?a1 < (1::?'a1) \<equiv>
### (0::?'a1) < ?a1 \<and> ?b1 < ?a1 \<or>
### ?a1 < (0::?'a1) \<and> ?a1 < ?b1 \<or> ?a1 = (0::?'a1)
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Rewrite rule not in simpset:
### numeral ?w1 \<le> ?b1 / ?c1 \<equiv>
### if (0::?'a1) < ?c1 then numeral ?w1 * ?c1 \<le> ?b1
### else if ?c1 < (0::?'a1) then ?b1 \<le> numeral ?w1 * ?c1
###      else numeral ?w1 \<le> (0::?'a1)
### Rewrite rule not in simpset:
### - numeral ?w1 \<le> ?b1 / ?c1 \<equiv>
### if (0::?'a1) < ?c1 then - numeral ?w1 * ?c1 \<le> ?b1
### else if ?c1 < (0::?'a1) then ?b1 \<le> - numeral ?w1 * ?c1
###      else - numeral ?w1 \<le> (0::?'a1)
### Rewrite rule not in simpset:
### ?b1 / ?c1 \<le> numeral ?w1 \<equiv>
### if (0::?'a1) < ?c1 then ?b1 \<le> numeral ?w1 * ?c1
### else if ?c1 < (0::?'a1) then numeral ?w1 * ?c1 \<le> ?b1
###      else (0::?'a1) \<le> numeral ?w1
### Rewrite rule not in simpset:
### ?b1 / ?c1 \<le> - numeral ?w1 \<equiv>
### if (0::?'a1) < ?c1 then ?b1 \<le> - numeral ?w1 * ?c1
### else if ?c1 < (0::?'a1) then - numeral ?w1 * ?c1 \<le> ?b1
###      else (0::?'a1) \<le> - numeral ?w1
### Rewrite rule not in simpset:
### numeral ?w1 < ?b1 / ?c1 \<equiv>
### if (0::?'a1) < ?c1 then numeral ?w1 * ?c1 < ?b1
### else if ?c1 < (0::?'a1) then ?b1 < numeral ?w1 * ?c1
###      else numeral ?w1 < (0::?'a1)
### Rewrite rule not in simpset:
### - numeral ?w1 < ?b1 / ?c1 \<equiv>
### if (0::?'a1) < ?c1 then - numeral ?w1 * ?c1 < ?b1
### else if ?c1 < (0::?'a1) then ?b1 < - numeral ?w1 * ?c1
###      else - numeral ?w1 < (0::?'a1)
### Rewrite rule not in simpset:
### ?b1 / ?c1 < numeral ?w1 \<equiv>
### if (0::?'a1) < ?c1 then ?b1 < numeral ?w1 * ?c1
### else if ?c1 < (0::?'a1) then numeral ?w1 * ?c1 < ?b1
###      else (0::?'a1) < numeral ?w1
### Rewrite rule not in simpset:
### ?b1 / ?c1 < - numeral ?w1 \<equiv>
### if (0::?'a1) < ?c1 then ?b1 < - numeral ?w1 * ?c1
### else if ?c1 < (0::?'a1) then - numeral ?w1 * ?c1 < ?b1
###      else (0::?'a1) < - numeral ?w1
### Rewrite rule not in simpset:
### numeral ?w1 = ?b1 / ?c1 \<equiv>
### if ?c1 \<noteq> (0::?'a1) then numeral ?w1 * ?c1 = ?b1
### else numeral ?w1 = (0::?'a1)
### Rewrite rule not in simpset:
### - numeral ?w1 = ?b1 / ?c1 \<equiv>
### if ?c1 \<noteq> (0::?'a1) then - numeral ?w1 * ?c1 = ?b1
### else - numeral ?w1 = (0::?'a1)
### Rewrite rule not in simpset:
### ?b1 / ?c1 = numeral ?w1 \<equiv>
### if ?c1 \<noteq> (0::?'a1) then ?b1 = numeral ?w1 * ?c1
### else numeral ?w1 = (0::?'a1)
### Rewrite rule not in simpset:
### ?b1 / ?c1 = - numeral ?w1 \<equiv>
### if ?c1 \<noteq> (0::?'a1) then ?b1 = - numeral ?w1 * ?c1
### else - numeral ?w1 = (0::?'a1)
### Rewrite rule not in simpset:
### (1::?'a1) \<le> ?b1 / ?a1 \<equiv>
### (0::?'a1) < ?a1 \<and> ?a1 \<le> ?b1 \<or>
### ?a1 < (0::?'a1) \<and> ?b1 \<le> ?a1
### Rewrite rule not in simpset:
### ?b1 / ?a1 \<le> (1::?'a1) \<equiv>
### (0::?'a1) < ?a1 \<and> ?b1 \<le> ?a1 \<or>
### ?a1 < (0::?'a1) \<and> ?a1 \<le> ?b1 \<or> ?a1 = (0::?'a1)
### Rewrite rule not in simpset:
### (1::?'a1) < ?b1 / ?a1 \<equiv>
### (0::?'a1) < ?a1 \<and> ?a1 < ?b1 \<or> ?a1 < (0::?'a1) \<and> ?b1 < ?a1
### Rewrite rule not in simpset:
### ?b1 / ?a1 < (1::?'a1) \<equiv>
### (0::?'a1) < ?a1 \<and> ?b1 < ?a1 \<or>
### ?a1 < (0::?'a1) \<and> ?a1 < ?b1 \<or> ?a1 = (0::?'a1)
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate introduction (intro)
### open {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### closed {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### closed UNIV
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Ignoring duplicate introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Ignoring duplicate introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Ignoring duplicate introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Ignoring duplicate rewrite rule:
### open {} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed UNIV \<equiv> True
### Ignoring duplicate rewrite rule:
### closed ?S1 \<Longrightarrow> closed (insert ?a1 ?S1) \<equiv> True
### Ignoring duplicate rewrite rule:
### open {?a1<..} \<equiv> True
### Ignoring duplicate rewrite rule:
### open {..<?a1} \<equiv> True
### Ignoring duplicate rewrite rule:
### open {?a1<..<?b1} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {..?a1} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {?a1..} \<equiv> True
### Ignoring duplicate rewrite rule:
### closed {?a1..?b1} \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 id \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous bot ?f1 \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous (at ?x1 within ?S1) (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous (at ?x1 within ?S1) id \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous ?F1 (\<lambda>x. ?c1) \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; isCont ?g1 ?a1; ?g1 ?a1 \<noteq> (0::?'b1)\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. ?f1 x / ?g1 x) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; isCont ?g1 ?a1; 0 < ?f1 ?a1; ?f1 ?a1 \<noteq> 1;
###  0 < ?g1 ?a1\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. log (?f1 x) (?g1 x)) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; isCont ?g1 ?a1; ?f1 ?a1 \<noteq> 0\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. ?f1 x powr ?g1 x) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; cos (?f1 ?a1) \<noteq> (0::?'a1)\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. tan (?f1 x)) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?a1; sin (?f1 ?a1) \<noteq> (0::?'a1)\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. cot (?f1 x)) ?a1 \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous ?F1 ?g1 \<Longrightarrow>
### continuous ?F1 (\<lambda>x. cnj (?g1 x)) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_on ?s1 ?g1 \<Longrightarrow>
### continuous_on ?s1 (\<lambda>x. cnj (?g1 x)) \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_map ?X1 ?X1 id \<equiv> True
### Ignoring duplicate rewrite rule:
### continuous_map ?X1 ?X1 (\<lambda>x. x) \<equiv> True
### Ignoring duplicate rewrite rule:
### \<lbrakk>isCont ?f1 ?z1;
###  ?f1 ?z1 \<notin> \<real>\<^sub>\<le>\<^sub>0\<rbrakk>
### \<Longrightarrow> isCont (\<lambda>x. Ln (?f1 x)) ?z1 \<equiv> True
### Metis: Unused theorems: "Set.Compl_eq_Diff_UNIV", "Convex.connected_UNIV", "Orderings.order_top_class.top_greatest"
### Metis: Unused theorems: "Connected.connected_component_sym"
### Metis: Unused theorems: "local.assms_7"
### Rewrite rule not in simpset:
### Complex ?a1 ?b1 \<equiv> complex_of_real ?a1 + \<i> * complex_of_real ?b1
### Rewrite rule not in simpset:
### Complex ?a1 ?b1 \<equiv> complex_of_real ?a1 + \<i> * complex_of_real ?b1
### Rewrite rule not in simpset:
### {0<..} \<equiv> range Suc
### Rewrite rule not in simpset:
### Complex ?a1 ?b1 \<equiv> complex_of_real ?a1 + \<i> * complex_of_real ?b1
### Rewrite rule not in simpset:
### Complex ?a1 ?b1 \<equiv> complex_of_real ?a1 + \<i> * complex_of_real ?b1
### Rewrite rule not in simpset:
### {0<..} \<equiv> range Suc
### Rewrite rule not in simpset:
### numeral ?w1 \<le> ?b1 / ?c1 \<equiv>
### if (0::?'a1) < ?c1 then numeral ?w1 * ?c1 \<le> ?b1
### else if ?c1 < (0::?'a1) then ?b1 \<le> numeral ?w1 * ?c1
###      else numeral ?w1 \<le> (0::?'a1)
### Rewrite rule not in simpset:
### - numeral ?w1 \<le> ?b1 / ?c1 \<equiv>
### if (0::?'a1) < ?c1 then - numeral ?w1 * ?c1 \<le> ?b1
### else if ?c1 < (0::?'a1) then ?b1 \<le> - numeral ?w1 * ?c1
###      else - numeral ?w1 \<le> (0::?'a1)
### Rewrite rule not in simpset:
### ?b1 / ?c1 \<le> numeral ?w1 \<equiv>
### if (0::?'a1) < ?c1 then ?b1 \<le> numeral ?w1 * ?c1
### else if ?c1 < (0::?'a1) then numeral ?w1 * ?c1 \<le> ?b1
###      else (0::?'a1) \<le> numeral ?w1
### Rewrite rule not in simpset:
### ?b1 / ?c1 \<le> - numeral ?w1 \<equiv>
### if (0::?'a1) < ?c1 then ?b1 \<le> - numeral ?w1 * ?c1
### else if ?c1 < (0::?'a1) then - numeral ?w1 * ?c1 \<le> ?b1
###      else (0::?'a1) \<le> - numeral ?w1
### Rewrite rule not in simpset:
### numeral ?w1 < ?b1 / ?c1 \<equiv>
### if (0::?'a1) < ?c1 then numeral ?w1 * ?c1 < ?b1
### else if ?c1 < (0::?'a1) then ?b1 < numeral ?w1 * ?c1
###      else numeral ?w1 < (0::?'a1)
### Rewrite rule not in simpset:
### - numeral ?w1 < ?b1 / ?c1 \<equiv>
### if (0::?'a1) < ?c1 then - numeral ?w1 * ?c1 < ?b1
### else if ?c1 < (0::?'a1) then ?b1 < - numeral ?w1 * ?c1
###      else - numeral ?w1 < (0::?'a1)
### Rewrite rule not in simpset:
### ?b1 / ?c1 < numeral ?w1 \<equiv>
### if (0::?'a1) < ?c1 then ?b1 < numeral ?w1 * ?c1
### else if ?c1 < (0::?'a1) then numeral ?w1 * ?c1 < ?b1
###      else (0::?'a1) < numeral ?w1
### Rewrite rule not in simpset:
### ?b1 / ?c1 < - numeral ?w1 \<equiv>
### if (0::?'a1) < ?c1 then ?b1 < - numeral ?w1 * ?c1
### else if ?c1 < (0::?'a1) then - numeral ?w1 * ?c1 < ?b1
###      else (0::?'a1) < - numeral ?w1
### Rewrite rule not in simpset:
### numeral ?w1 = ?b1 / ?c1 \<equiv>
### if ?c1 \<noteq> (0::?'a1) then numeral ?w1 * ?c1 = ?b1
### else numeral ?w1 = (0::?'a1)
### Rewrite rule not in simpset:
### - numeral ?w1 = ?b1 / ?c1 \<equiv>
### if ?c1 \<noteq> (0::?'a1) then - numeral ?w1 * ?c1 = ?b1
### else - numeral ?w1 = (0::?'a1)
### Rewrite rule not in simpset:
### ?b1 / ?c1 = numeral ?w1 \<equiv>
### if ?c1 \<noteq> (0::?'a1) then ?b1 = numeral ?w1 * ?c1
### else numeral ?w1 = (0::?'a1)
### Rewrite rule not in simpset:
### ?b1 / ?c1 = - numeral ?w1 \<equiv>
### if ?c1 \<noteq> (0::?'a1) then ?b1 = - numeral ?w1 * ?c1
### else - numeral ?w1 = (0::?'a1)
### Rewrite rule not in simpset:
### (1::?'a1) \<le> ?b1 / ?a1 \<equiv>
### (0::?'a1) < ?a1 \<and> ?a1 \<le> ?b1 \<or>
### ?a1 < (0::?'a1) \<and> ?b1 \<le> ?a1
### Rewrite rule not in simpset:
### ?b1 / ?a1 \<le> (1::?'a1) \<equiv>
### (0::?'a1) < ?a1 \<and> ?b1 \<le> ?a1 \<or>
### ?a1 < (0::?'a1) \<and> ?a1 \<le> ?b1 \<or> ?a1 = (0::?'a1)
### Rewrite rule not in simpset:
### (1::?'a1) < ?b1 / ?a1 \<equiv>
### (0::?'a1) < ?a1 \<and> ?a1 < ?b1 \<or> ?a1 < (0::?'a1) \<and> ?b1 < ?a1
### Rewrite rule not in simpset:
### ?b1 / ?a1 < (1::?'a1) \<equiv>
### (0::?'a1) < ?a1 \<and> ?b1 < ?a1 \<or>
### ?a1 < (0::?'a1) \<and> ?a1 < ?b1 \<or> ?a1 = (0::?'a1)
### Metis: Unused theorems: "local.z12_1"
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Ignoring duplicate rewrite rule:
### ?x1 \<le> of_int \<lceil>?x1\<rceil> \<equiv> True
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### 0 < ?n1 \<Longrightarrow>
### Ln (of_nat ?n1) \<equiv> complex_of_real (ln (real ?n1))
### Ignoring duplicate rewrite rule:
### 0 < ?n1 \<Longrightarrow>
### Ln (of_nat ?n1) \<equiv> complex_of_real (ln (real ?n1))
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
?z \<notin> \<int>\<^sub>\<le>\<^sub>0 \<Longrightarrow>
(Polygamma ?n has_field_derivative Polygamma (Suc ?n) ?z) (at ?z within ?A)
### Metis: Unused theorems: "local.znot_2"
### Metis: Unused theorems: "local.sp_1", "local.sp_2"
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### dist (0::?'a1) ?x1 \<equiv> norm ?x1
### Ignoring duplicate rewrite rule:
### dist (0::?'a1) ?x1 \<equiv> norm ?x1
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### netlimit (at ?y) \<equiv> ?y
### Ignoring duplicate rewrite rule:
### netlimit (at ?y) \<equiv> ?y
### Ignoring duplicate rewrite rule:
### 0 < ?n1 \<Longrightarrow>
### Ln (of_nat ?n1) \<equiv> complex_of_real (ln (real ?n1))
### Ignoring duplicate rewrite rule:
### netlimit (at ?y) \<equiv> ?y
### Ignoring duplicate rewrite rule:
### netlimit (at ?y) \<equiv> ?y
### Ignoring duplicate rewrite rule:
### 0 < ?n1 \<Longrightarrow>
### Ln (of_nat ?n1) \<equiv> complex_of_real (ln (real ?n1))
### Rule already declared as introduction (intro)
### 0 < ?x \<Longrightarrow> 0 < Gamma ?x
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### dist (0::?'a1) ?x1 \<equiv> norm ?x1
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Rule already declared as elimination (elim)
### \<lbrakk>?x \<in> \<int>\<^sub>\<le>\<^sub>0;
###  ?x \<in> \<int> \<Longrightarrow> PROP ?W\<rbrakk>
### \<Longrightarrow> PROP ?W
### Ignoring duplicate rewrite rule:
### ?y gchoose 1 \<equiv> ?y
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Ignoring duplicate rewrite rule:
### dist (0::?'a1) ?x1 \<equiv> norm ?x1
### Rule already declared as introduction (intro)
### (\<And>x. x \<in> space ?M \<Longrightarrow> ?P x) \<Longrightarrow>
### almost_everywhere ?M ?P
### Ignoring duplicate rewrite rule:
### 0 < ?n1 \<Longrightarrow>
### Ln (of_nat ?n1) \<equiv> complex_of_real (ln (real ?n1))
### Rule already declared as introduction (intro)
### (\<And>x. x \<in> space ?M \<Longrightarrow> ?P x) \<Longrightarrow>
### almost_everywhere ?M ?P
### Ignoring duplicate rewrite rule:
### cball ?x1 ?e1 = {} \<equiv> ?e1 < 0
### Ignoring duplicate rewrite rule:
### dist (0::?'a1) ?x1 \<equiv> norm ?x1
### Ignoring duplicate rewrite rule:
### dist (0::?'a1) ?x1 \<equiv> norm ?x1
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Rule already declared as introduction (intro)
### open {}
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### closed {}
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Rule already declared as introduction (intro)
### closed UNIV
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Rule already declared as introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Rule already declared as introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Rule already declared as introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Rule already declared as introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Rule already declared as introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Rule already declared as introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Rule already declared as introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### sqrt ?x1 < sqrt ?y1 \<equiv> ?x1 < ?y1
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate introduction (intro)
### open {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; open ?T\<rbrakk> \<Longrightarrow> open (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. open (?B x) \<Longrightarrow> open (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. open T\<rbrakk>
### \<Longrightarrow> open (\<Inter> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. open (?B x)\<rbrakk>
### \<Longrightarrow> open (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### closed {}
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<union> ?T)
### Ignoring duplicate introduction (intro)
### closed UNIV
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; closed ?T\<rbrakk>
### \<Longrightarrow> closed (?S \<inter> ?T)
### Ignoring duplicate introduction (intro)
### \<forall>x\<in>?A. closed (?B x) \<Longrightarrow>
### closed (\<Inter> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<forall>S\<in>?K. closed S \<Longrightarrow> closed (\<Inter> ?K)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?S; \<forall>T\<in>?S. closed T\<rbrakk>
### \<Longrightarrow> closed (\<Union> ?S)
### Ignoring duplicate introduction (intro)
### \<lbrakk>finite ?A; \<forall>x\<in>?A. closed (?B x)\<rbrakk>
### \<Longrightarrow> closed (\<Union> (?B ` ?A))
### Ignoring duplicate introduction (intro)
### \<lbrakk>open ?S; closed ?T\<rbrakk> \<Longrightarrow> open (?S - ?T)
### Ignoring duplicate introduction (intro)
### \<lbrakk>closed ?S; open ?T\<rbrakk> \<Longrightarrow> closed (?S - ?T)
### Ignoring duplicate introduction (intro)
### closed ?S \<Longrightarrow> open (- ?S)
### Ignoring duplicate introduction (intro)
### open ?S \<Longrightarrow> closed (- ?S)
### Ignoring duplicate introduction (intro)
### continuous_on ?s (linepath ?a ?b)
### Ignoring duplicate rewrite rule:
### \<Prod>x\<in>?A1. ?y1 \<equiv> ?y1 ^ card ?A1
### Ignoring duplicate introduction (intro)
### ((\<lambda>x. x) \<longlongrightarrow> ?a) (at ?a within ?s)
### Ignoring duplicate introduction (intro)
### ((\<lambda>x. ?k) \<longlongrightarrow> ?k) ?F
### Ignoring duplicate introduction (intro)
### (?f \<longlongrightarrow> ?x) ?F \<Longrightarrow>
### ((\<lambda>x. ereal (?f x)) \<longlongrightarrow> ereal ?x) ?F
### Ignoring duplicate introduction (intro)
### (?f \<longlongrightarrow> ?x) ?F \<Longrightarrow>
### ((\<lambda>x. - ?f x) \<longlongrightarrow> - ?x) ?F
### Ignoring duplicate introduction (intro)
### \<lbrakk>\<bar>?c\<bar> \<noteq> \<infinity>;
###  (?f \<longlongrightarrow> ?x) ?F\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?c * ?f x) \<longlongrightarrow> ?c * ?x) ?F
### Ignoring duplicate introduction (intro)
### \<lbrakk>?x \<noteq> 0; (?f \<longlongrightarrow> ?x) ?F\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?c * ?f x) \<longlongrightarrow> ?c * ?x) ?F
### Ignoring duplicate introduction (intro)
### \<lbrakk>?y \<noteq> - \<infinity>; ?x \<noteq> - \<infinity>;
###  (?f \<longlongrightarrow> ?x) ?F\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?f x + ?y) \<longlongrightarrow> ?x + ?y) ?F
### Ignoring duplicate introduction (intro)
### \<lbrakk>\<bar>?y\<bar> \<noteq> \<infinity>;
###  (?f \<longlongrightarrow> ?x) ?F\<rbrakk>
### \<Longrightarrow> ((\<lambda>x. ?f x + ?y) \<longlongrightarrow> ?x + ?y) ?F
### Ignoring duplicate introduction (intro)
### (?f \<longlongrightarrow> ?x) ?F \<Longrightarrow>
### ((\<lambda>x. ennreal (?f x)) \<longlongrightarrow> ennreal ?x) ?F
### Ignoring duplicate rewrite rule:
### (?P1 \<and> ?Q1) \<and> ?R1 \<equiv> ?P1 \<and> ?Q1 \<and> ?R1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 < (0::?'a1) \<equiv>
### (0::?'a1) < ?a1 \<and> ?b1 < (0::?'a1) \<or>
### ?a1 < (0::?'a1) \<and> (0::?'a1) < ?b1
### Ignoring duplicate rewrite rule:
### ?c1 \<noteq> 0 \<Longrightarrow>
### (\<lambda>x. ?c1 * ?f1 x) integrable_on ?S1 \<equiv> ?f1 integrable_on ?S1
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 + ?c1 \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + ?b1 \<equiv> ?b1 + ?a1
### Ignoring duplicate rewrite rule:
### ?b1 + (?a1 + ?c1) \<equiv> ?a1 + (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 - ?c1 \<equiv> ?a1 - (?b1 + ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 + (?b1 - ?c1) \<equiv> ?a1 + ?b1 - ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 = ?c1 \<equiv> ?a1 = ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 = ?c1 - ?b1 \<equiv> ?a1 + ?b1 = ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - (?b1 - ?c1) \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 + ?c1 \<equiv> ?a1 + ?c1 - ?b1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 < ?c1 \<equiv> ?a1 < ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 < ?c1 - ?b1 \<equiv> ?a1 + ?b1 < ?c1
### Ignoring duplicate rewrite rule:
### ?a1 - ?b1 \<le> ?c1 \<equiv> ?a1 \<le> ?c1 + ?b1
### Ignoring duplicate rewrite rule:
### ?a1 \<le> ?c1 - ?b1 \<equiv> ?a1 + ?b1 \<le> ?c1
### Ignoring duplicate rewrite rule:
### (?a1 * ?b1) ^ ?n1 \<equiv> ?a1 ^ ?n1 * ?b1 ^ ?n1
### Ignoring duplicate rewrite rule:
### linear ((*v) ?A1) \<equiv> True
?a \<in> affine hull ?S \<Longrightarrow>
aff_dim ?S = int (dim ((+) (- ?a) ` ?S))
sigma_finite_measure (count_space ?A)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 * ?c1 \<equiv> ?a1 * (?b1 * ?c1)
### Ignoring duplicate rewrite rule:
### ?a1 * ?b1 \<equiv> ?b1 * ?a1
### Ignoring duplicate rewrite rule:
### ?b1 * (?a1 * ?c1) \<equiv> ?a1 * (?b1 * ?c1)