Anforderungen  |   Konzepte  |   Entwurf  |   Entwicklung  |   Qualitätssicherung  |   Lebenszyklus  |   Steuerung
 
 
 
 


Impressum exp_series.prf

  Sprache: Lisp
 

(exp_series
 (IMP_taylor_series_TCC1 0
  (IMP_taylor_series_TCC1-1 nil 3568830993 ("" (assuming-tcc) nil nil)
   ((connected? const-decl "bool" deriv_domain_def "analysis/")) nil))
 (IMP_taylor_series_TCC2 0
  (IMP_taylor_series_TCC2-1 nil 3568830993 ("" (assertnil nil)
   ((not_one_element_real formula-decl nil deriv_domain "analysis/"))
   nil))
 (IMP_taylor_series_TCC3 0
  (IMP_taylor_series_TCC3-1 nil 3568830993 ("" (assuming-tcc) nil nil)
   nil nil))
 (IMP_taylor_series_TCC4 0
  (IMP_taylor_series_TCC4-1 nil 3568830993 ("" (assuming-tcc) nil nil)
   nil nil))
 (nderiv_exp_TCC1 0
  (nderiv_exp_TCC1-1 nil 3563622656
   ("" (lemma "deriv_domain_real") (("" (propax) nil nil)) nil)
   ((deriv_domain_real formula-decl nil deriv_domain "analysis/"))
   nil))
 (nderiv_exp 0
  (nderiv_exp-1 nil 3298644142
   ("" (induct "n")
    (("1" (lemma "exp_deriv")
      (("1" (flatten)
        (("1" (expand "derivable_n_times?")
          (("1" (assert)
            (("1" (expand "derivable_n_times?")
              (("1" (propax) nil nil)) nil))
            nil))
          nil))
        nil))
      nil)
     ("2" (expand "nderiv" 1)
      (("2" (expand "nderiv")
        (("2" (lemma "exp_deriv") (("2" (flatten) nil nil)) nil)) nil))
      nil)
     ("3" (skosimp*)
      (("3" (lemma "exp_deriv")
        (("3" (flatten)
          (("3" (prop)
            (("1" (expand "derivable_n_times?" 1)
              (("1" (assertnil nil)) nil)
             ("2" (expand "nderiv" 1) (("2" (assertnil nil)) nil))
            nil))
          nil))
        nil))
      nil)
     ("4" (skosimp*) nil nil) ("5" (skosimp*) nil nil))
    nil)
   ((exp_deriv formula-decl nil ln_exp nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (nderiv def-decl "[T -> real]" nth_derivatives "analysis/")
    (nderiv_fun type-eq-decl nil nth_derivatives "analysis/")
    (exp const-decl "{py | x = ln(py)}" ln_exp nil)
    (ln const-decl "real" ln_exp nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (derivable_n_times? def-decl "bool" nth_derivatives "analysis/")
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (exp_inf_deriv 0
  (exp_inf_deriv-1 nil 3298647578
   ("" (expand "inf_deriv_fun?")
    (("" (induct "n")
      (("1" (lemma "nderiv_exp")
        (("1" (inst?) (("1" (flatten) nil nil)) nil)) nil)
       ("2" (skosimp*)
        (("2" (expand "derivable_n_times?" 1)
          (("2" (lemma "exp_deriv")
            (("2" (flatten) (("2" (assertnil nil)) nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (derivable_n_times? def-decl "bool" nth_derivatives "analysis/")
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (ln const-decl "real" ln_exp nil)
    (exp const-decl "{py | x = ln(py)}" ln_exp nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (nderiv_exp formula-decl nil exp_series nil)
    (exp_deriv formula-decl nil ln_exp nil)
    (inf_deriv_fun? const-decl "bool" taylors "analysis/"))
   shostak))
 (exp_series_prep_TCC1 0
  (exp_series_prep_TCC1-1 nil 3298643720
   ("" (skosimp*)
    (("" (assert)
      (("" (lemma "nderiv_exp")
        (("" (inst?) (("" (flatten) nil nil)) nil)) nil))
      nil))
    nil)
   ((posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nderiv_exp formula-decl nil exp_series nil))
   shostak))
 (exp_series_prep_TCC2 0
  (exp_series_prep_TCC2-1 nil 3298643720
   ("" (rewrite "exp_inf_deriv"nil nil)
   ((exp_inf_deriv formula-decl nil exp_series nil)) shostak))
 (exp_series_prep 0
  (exp_series_prep-3 nil 3298638694
   ("" (skosimp*)
    (("" (lemma "squeezing_abs_0")
      (("" (inst?)
        (("1" (assert)
          (("1"
            (case "EXISTS (M: posreal): (FORALL (t: between[real](0,x!1)): exp(t) <= M)")
            (("1" (skosimp*)
              (("1"
                (inst -2
                 "(LAMBDA n: M!1*abs(x!1)^(n+1)/factorial(n+1))")
                (("1" (assert)
                  (("1" (hide 2)
                    (("1" (prop)
                      (("1" (lemma "conv_x_to_n_div_fact")
                        (("1" (inst - "abs(x!1)")
                          (("1" (lemma "convergence_shift")
                            (("1" (inst?)
                              (("1"
                                (inst - "1")
                                (("1"
                                  (assert)
                                  (("1"
                                    (lemma "cnv_seq_scal")
                                    (("1"
                                      (inst?)
                                      (("1"
                                        (inst - "M!1")
                                        (("1"
                                          (assert)
                                          (("1"
                                            (expand "*")
                                            (("1" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (skosimp*)
                        (("2" (expand "Taylor_rem")
                          (("2" (rewrite "abs_div")
                            (("2" (expand "abs" 1 2)
                              (("2"
                                (cross-mult 1)
                                (("2"
                                  (assert)
                                  (("2"
                                    (name-replace
                                     "C"
                                     "GET_C(exp, x!1, n!1)")
                                    (("2"
                                      (field 1)
                                      (("2"
                                        (cancel-terms 1)
                                        (("2"
                                          (inst - "C")
                                          (("2"
                                            (rewrite "abs_hat")
                                            (("1"
                                              (expand "abs" 1 1)
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (lemma "nderiv_exp")
                                                  (("1"
                                                    (inst - "n!1+1")
                                                    (("1"
                                                      (flatten)
                                                      (("1"
                                                        (replace -2)
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (hide
                                                             -1
                                                             -2)
                                                            (("1"
                                                              (expand
                                                               "abs"
                                                               1
                                                               1)
                                                              (("1"
                                                                (mult-by
                                                                 -1
                                                                 "abs(x!1) ^ (1 + n!1)")
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (case-replace "x!1 = 0")
                                              (("1"
                                                (expand "^")
                                                (("1"
                                                  (expand "expt")
                                                  (("1"
                                                    (expand "abs")
                                                    (("1"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2" (assertnil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (hide 2)
              (("2" (hide -1)
                (("2" (inst + "exp(abs(x!1))")
                  (("2" (skosimp*)
                    (("2" (lemma "exp_increasing")
                      (("2" (expand "increasing?")
                        (("2" (inst?)
                          (("2" (assert)
                            (("2" (hide 2)
                              (("2"
                                (typepred "x!1")
                                (("2"
                                  (typepred "t!1")
                                  (("2"
                                    (expand "abs")
                                    (("2"
                                      (lift-if)
                                      (("2" (ground) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (rewrite "exp_inf_deriv"nil nil)
         ("3" (skosimp*)
          (("3" (lemma "exp_inf_deriv")
            (("3" (expand "inf_deriv_fun?") (("3" (inst?) nil nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((squeezing_abs_0 formula-decl nil convergence_ops "analysis/")
    (exp_inf_deriv formula-decl nil exp_series nil)
    (exp_increasing formula-decl nil ln_exp nil)
    (minus_real_is_real application-judgement "real" reals nil)
    (increasing? const-decl "bool" real_fun_preds "reals/")
    (nnreal_times_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (nnreal_exp application-judgement "nnreal" exponentiation nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (* const-decl "[T -> real]" real_fun_ops "reals/")
    (cnv_seq_scal formula-decl nil convergence_ops "analysis/")
    (convergence_shift formula-decl nil convergence_ops "analysis/")
    (conv_x_to_n_div_fact formula-decl nil convergence_special nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (nnreal type-eq-decl nil real_types nil)
    (both_sides_times_pos_le1 formula-decl nil real_props nil)
    (nzreal nonempty-type-eq-decl nil reals nil)
    (abs_hat formula-decl nil exponent_props "reals/")
    (int_minus_int_is_int application-judgement "int" integers nil)
    (both_sides_times_pos_le1_imp formula-decl nil extra_real_props
     nil)
    (nderiv_exp formula-decl nil exp_series nil)
    (nat_expt application-judgement "nat" exponentiation nil)
    (expt def-decl "real" exponentiation nil)
    (nat_exp application-judgement "nat" exponentiation nil)
    (both_sides_times_pos_le2 formula-decl nil real_props nil)
    (abs_mult formula-decl nil real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (div_mult_pos_le2 formula-decl nil real_props nil)
    (times_div2 formula-decl nil real_props nil)
    (div_mult_pos_le1 formula-decl nil real_props nil)
    (nzint_abs_is_pos application-judgement "{j: posint | j >= i}"
     real_defs nil)
    (abs_div formula-decl nil real_props nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (nderiv def-decl "[T -> real]" nth_derivatives "analysis/")
    (/= const-decl "boolean" notequal nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (^ const-decl "real" exponentiation nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (factorial def-decl "posnat" factorial "ints/")
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (nnreal_div_posreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (<= const-decl "bool" reals nil)
    (GET_C const-decl "{c: between[T](0, x) |
         powerseries(Taylor_seq(f))(x)(k) =
          f(x) - Taylor_rem(k, f, 0, x, c)}" taylor_series "series/")
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (Taylor_seq const-decl "real" taylor_series "series/")
    (powerseries const-decl "sequence[real]" power_series "series/")
    (Taylor_rem const-decl "real" taylors "analysis/")
    (between type-eq-decl nil taylors "analysis/")
    (< const-decl "bool" reals nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (nderiv_fun type-eq-decl nil nth_derivatives "analysis/")
    (sequence type-eq-decl nil sequences nil)
    (inf_deriv_fun? const-decl "bool" taylors "analysis/")
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (derivable_n_times? def-decl "bool" nth_derivatives "analysis/")
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (ln const-decl "real" ln_exp nil)
    (exp const-decl "{py | x = ln(py)}" ln_exp nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields
       nil))
   nil)
  (exp_series_prep-2 nil 3298638280
   ("" (skosimp*)
    (("" (lemma "squeezing_abs_0")
      (("" (inst?)
        (("1" (assert)
          (("1"
            (case "EXISTS (M: posreal): FORALL t: 0 <= t IMPLIES exp(t) <= M")
            (("1" (skosimp*)
              (("1"
                (inst -2
                 "(LAMBDA n: M!1*abs(x!1)^(n+1)/factorial(n+1))")
                (("1" (assert)
                  (("1" (prop)
                    (("1" (hide 2) (("1" (postpone) nil nil)) nil)
                     ("2" (skosimp*)
                      (("2" (hide 2)
                        (("2" (expand "Taylor_rem")
                          (("2" (rewrite "nderiv_exp")
                            (("2" (rewrite "abs_div")
                              (("1"
                                (expand "abs" 1 2)
                                (("1"
                                  (cross-mult 1)
                                  (("1"
                                    (assert)
                                    (("1"
                                      (name-replace
                                       "C"
                                       "GET_C(exp, x!1, n!1)")
                                      (("1"
                                        (field 1)
                                        (("1" (postpone) nil nil))
                                        nil)
                                       ("2"
                                        (skosimp*)
                                        (("2"
                                          (inst + "x!2+1")
                                          (("2" (assertnil nil))
                                          nil))
                                        nil)
                                       ("3" (postpone) nil nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (skosimp*)
                                    (("2"
                                      (inst + "x!2+1")
                                      (("2" (assertnil nil))
                                      nil))
                                    nil)
                                   ("3" (postpone) nil nil))
                                  nil))
                                nil)
                               ("2"
                                (skosimp*)
                                (("2"
                                  (inst + "x!2+1")
                                  (("2" (assertnil nil))
                                  nil))
                                nil)
                               ("3" (postpone) nil nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (postpone) nil nil))
            nil))
          nil)
         ("2" (skosimp*)
          (("2" (inst + "x!2+1") (("2" (assertnil nil)) nil)) nil)
         ("3" (postpone) nil nil) ("4" (postpone) nil nil))
        nil))
      nil))
    nil)
   nil nil)
  (exp_series_prep-1 nil 3298633339
   ("" (skosimp*)
    (("" (lemma "squeezing_abs_0")
      (("" (inst?)
        (("1" (assert)
          (("1"
            (case "EXISTS (M: posreal): FORALL t: 0 <= x!1 IMPLIES exp(t) <= M")
            (("1" (skosimp*)
              (("1"
                (inst -2
                 "(LAMBDA n: M!1*abs(x!1)^(n+1)/factorial(n+1))")
                (("1" (assert)
                  (("1" (prop)
                    (("1" (hide 2) (("1" (postpone) nil nil)) nil)
                     ("2" (skosimp*)
                      (("2" (hide 2)
                        (("2" (expand "Taylor_rem")
                          (("2" (rewrite "nderiv_exp")
                            (("2" (rewrite "abs_div")
                              (("1"
                                (expand "abs" 1 2)
                                (("1"
                                  (cross-mult 1)
                                  (("1"
                                    (assert)
                                    (("1"
                                      (name-replace
                                       "C"
                                       "GET_C(exp, x!1, n!1)")
                                      (("1"
                                        (field 1)
                                        (("1"
                                          (inst - "C")
                                          (("1" (postpone) nil nil))
                                          nil))
                                        nil)
                                       ("2" (postpone) nil nil)
                                       ("3" (postpone) nil nil))
                                      nil))
                                    nil)
                                   ("2" (postpone) nil nil)
                                   ("3" (postpone) nil nil))
                                  nil))
                                nil)
                               ("2"
                                (skosimp*)
                                (("2"
                                  (inst + "x!2+1")
                                  (("2" (assertnil nil))
                                  nil))
                                nil)
                               ("3" (postpone) nil nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (postpone) nil nil))
            nil))
          nil)
         ("2" (skosimp*)
          (("2" (inst + "x!2+1") (("2" (assertnil nil)) nil)) nil)
         ("3" (postpone) nil nil)
         ("4" (skosimp*) (("4" (postpone) nil nil)) nil))
        nil))
      nil))
    nil)
   nil shostak))
 (conv_exp 0
  (conv_exp-2 nil 3445687755
   ("" (lemma "is_taylor_prep")
    (("" (inst - "exp")
      (("" (assert)
        (("" (case-replace "Taylor_seq[real](exp) = exp_seq")
          (("1" (assert)
            (("1" (rewrite "exp_inf_deriv")
              (("1" (skosimp*)
                (("1" (lemma "exp_series_prep")
                  (("1" (inst?)
                    (("1" (expand "convergent?")
                      (("1" (inst + "0"nil nil)) nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (hide -1 2)
            (("2" (expand "Taylor_seq")
              (("2" (expand "exp_seq")
                (("2" (apply-extensionality 1 :hide? t)
                  (("1" (lemma "nderiv_exp")
                    (("1" (inst?)
                      (("1" (flatten)
                        (("1" (replace -2)
                          (("1" (rewrite "exp_0"nil nil)) nil))
                        nil))
                      nil))
                    nil)
                   ("2" (skosimp*)
                    (("2" (lemma "nderiv_exp")
                      (("2" (inst?) (("2" (flatten) nil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("3" (rewrite "exp_inf_deriv"nil nil))
          nil))
        nil))
      nil))
    nil)
   ((bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (ln const-decl "real" ln_exp nil)
    (exp const-decl "{py | x = ln(py)}" ln_exp nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (inf_deriv_fun? const-decl "bool" taylors "analysis/")
    (Taylor_seq const-decl "real" taylor_series "series/")
    (exp_seq const-decl "real" exp_series nil)
    (exp_inf_deriv formula-decl nil exp_series nil)
    (exp_series_prep formula-decl nil exp_series nil)
    (convergent? const-decl "bool" convergence_sequences "analysis/")
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (factorial def-decl "posnat" factorial "ints/")
    (posnat nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (nderiv def-decl "[T -> real]" nth_derivatives "analysis/")
    (nderiv_fun type-eq-decl nil nth_derivatives "analysis/")
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/= const-decl "boolean" notequal nil)
    (derivable_n_times? def-decl "bool" nth_derivatives "analysis/")
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (posrat_div_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (exp_0 formula-decl nil ln_exp nil)
    (nderiv_exp formula-decl nil exp_series nil)
    (is_taylor_prep formula-decl nil taylor_series "series/")
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil))
   nil)
  (conv_exp-1 nil 3298646416
   ("" (lemma "is_taylor_prep")
    (("" (inst - "exp")
      (("" (assert)
        (("" (case-replace "Taylor_seq[real](exp) = exp_seq")
          (("1" (assert)
            (("1" (rewrite "exp_inf_deriv")
              (("1" (skosimp*)
                (("1" (lemma "exp_series_prep")
                  (("1" (inst?)
                    (("1" (expand "convergent")
                      (("1" (inst + "0"nil nil)) nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (hide -1 2)
            (("2" (expand "Taylor_seq")
              (("2" (expand "exp_seq")
                (("2" (apply-extensionality 1 :hide? t)
                  (("1" (lemma "nderiv_exp")
                    (("1" (inst?)
                      (("1" (flatten)
                        (("1" (replace -2)
                          (("1" (rewrite "exp_0"nil nil)) nil))
                        nil))
                      nil))
                    nil)
                   ("2" (skosimp*)
                    (("2" (lemma "nderiv_exp")
                      (("2" (inst?) (("2" (flatten) nil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("3" (rewrite "exp_inf_deriv"nil nil))
          nil))
        nil))
      nil))
    nil)
   ((is_taylor_prep formula-decl nil taylor_series "series/")
    (exp_0 formula-decl nil ln_exp nil)
    (Taylor_seq const-decl "real" taylor_series "series/")
    (exp const-decl "{py | x = ln(py)}" ln_exp nil)
    (ln const-decl "real" ln_exp nil))
   shostak))
 (exp_series_TCC1 0
  (exp_series_TCC1-1 nil 3298643720 ("" (rewrite "conv_exp"nil nil)
   ((conv_exp formula-decl nil exp_series nil)) shostak))
 (exp_series 0
  (exp_series-1 nil 3298643739
   ("" (lemma "is_taylor[real]")
    (("" (inst?)
      (("" (assert)
        (("" (split -1)
          (("1" (replace -1)
            (("1" (case-replace "Taylor_seq[real](exp) = exp_seq")
              (("1" (hide 2)
                (("1" (expand "Taylor_seq")
                  (("1" (expand "exp_seq")
                    (("1" (apply-extensionality 1 :hide? t)
                      (("1" (lemma "nderiv_exp")
                        (("1" (inst - "x!1")
                          (("1" (flatten)
                            (("1" (assert)
                              (("1"
                                (replace -2)
                                (("1" (rewrite "exp_0"nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (skosimp*)
                        (("2" (lemma "nderiv_exp")
                          (("2" (inst?) (("2" (flatten) nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (rewrite "exp_inf_deriv"nil nil)
           ("3" (skosimp*) (("3" (rewrite "exp_series_prep"nil nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (ln const-decl "real" ln_exp nil)
    (exp const-decl "{py | x = ln(py)}" ln_exp nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (inf_deriv_fun? const-decl "bool" taylors "analysis/")
    (Taylor_seq const-decl "real" taylor_series "series/")
    (exp_seq const-decl "real" exp_series nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (factorial def-decl "posnat" factorial "ints/")
    (posnat nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (nderiv def-decl "[T -> real]" nth_derivatives "analysis/")
    (nderiv_fun type-eq-decl nil nth_derivatives "analysis/")
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/= const-decl "boolean" notequal nil)
    (derivable_n_times? def-decl "bool" nth_derivatives "analysis/")
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (posrat_div_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (exp_0 formula-decl nil ln_exp nil)
    (nderiv_exp formula-decl nil exp_series nil)
    (exp_inf_deriv formula-decl nil exp_series nil)
    (exp_series_prep formula-decl nil exp_series nil)
    (is_taylor formula-decl nil taylor_series "series/")
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil))
   shostak))
 (exp_estimate_TCC1 0
  (exp_estimate_TCC1-1 nil 3302449689
   ("" (skosimp*) (("" (assertnil nil)) nil)
   ((real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   shostak))
 (exp_estimate_TCC2 0
  (exp_estimate_TCC2-1 nil 3403261760
   ("" (skosimp*) (("" (assertnil nil)) nil)
   ((real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (exp_estimate_TCC3 0
  (exp_estimate_TCC3-1 nil 3403261760
   ("" (skosimp*) (("" (assertnil nil)) nil)
   ((real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (exp_taylors_TCC1 0
  (exp_taylors_TCC1-1 nil 3302449689
   ("" (skosimp*) (("" (assertnil nil)) nil)
   ((nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   shostak))
 (exp_taylors 0
  (exp_taylors-2 nil 3352447184
   ("" (skosimp*)
    ((""
      (lemma "Taylors[real]" ("f" "exp" "n" "n!1" "aa" "0" "bb" "x!1"))
      ((""
        (lemma "sigma_eq[nat]"
         ("low" "1" "high" "n!1" "F" "LAMBDA (nn:nat):
                           IF nn > n!1 THEN 0
                           ELSIF nn = 0 THEN exp(0)
                           ELSE nderiv(nn, exp)(0) * (x!1 - 0) ^ nn / factorial(nn)
                           ENDIF" "G"
          "LAMBDA (nn: nat): x!1 ^ nn / factorial(nn)"))
        (("1" (assert)
          (("1" (expand "exp_estimate")
            (("1" (split -1)
              (("1" (rewrite "sigma_first" -2)
                (("1" (replace -1)
                  (("1" (hide -1)
                    (("1" (lemma "nderiv_exp" ("n" "n!1+1"))
                      (("1" (flatten) (("1" (assertnil nil)) nil))
                      nil))
                    nil))
                  nil)
                 ("2" (case-replace "n!1 = 0")
                  (("1" (assert)
                    (("1" (expand "sigma")
                      (("1" (split -3)
                        (("1" (lemma "nderiv_exp")
                          (("1" (inst?)
                            (("1" (flatten)
                              (("1"
                                (replace -2)
                                (("1" (propax) nil nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (lemma "nderiv_exp")
                          (("2" (inst?) (("2" (flatten) nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (assertnil nil))
                  nil))
                nil)
               ("2" (skosimp*)
                (("2" (hide 2)
                  (("2" (hide -1)
                    (("2" (lemma "nderiv_exp")
                      (("2" (inst?)
                        (("2" (flatten)
                          (("2" (replace -2) (("2" (assertnil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (skosimp*)
          (("2" (assert)
            (("2" (hide - 4)
              (("2" (lemma "nderiv_exp")
                (("2" (inst?) (("2" (flatten) nil nil)) nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (exp const-decl "{py | x = ln(py)}" ln_exp nil)
    (ln const-decl "real" ln_exp nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (Taylors formula-decl nil taylors "analysis/")
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (exp_0 formula-decl nil ln_exp nil)
    (nderiv_exp formula-decl nil exp_series nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (even_plus_odd_is_odd application-judgement "odd_int" integers nil)
    (sigma_first formula-decl nil sigma "reals/")
    (subrange type-eq-decl nil integers nil)
    (exp_estimate const-decl "real" exp_series nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (sigma_eq formula-decl nil sigma "reals/")
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (/= const-decl "boolean" notequal nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (derivable_n_times? def-decl "bool" nth_derivatives "analysis/")
    (nderiv_fun type-eq-decl nil nth_derivatives "analysis/")
    (nderiv def-decl "[T -> real]" nth_derivatives "analysis/")
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (^ const-decl "real" exponentiation nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (factorial def-decl "posnat" factorial "ints/")
    (<= const-decl "bool" reals nil)
    (T_high type-eq-decl nil sigma "reals/")
    (T_low type-eq-decl nil sigma "reals/"))
   nil)
  (exp_taylors-1 nil 3302448557
   ("" (skosimp*)
    (("" (lemma "Taylors" ("f" "exp" "n" "n!1" "aa" "0" "bb" "x!1"))
      ((""
        (lemma "sigma_eq[nat]"
         ("low" "1" "high" "n!1" "F" "LAMBDA (nn:nat):
                        IF nn > n!1 THEN 0
                        ELSIF nn = 0 THEN exp(0)
                        ELSE nderiv(nn, exp)(0) * (x!1 - 0) ^ nn / factorial(nn)
                        ENDIF" "G"
          "LAMBDA (nn: nat): x!1 ^ nn / factorial(nn)"))
        (("1" (assert)
          (("1" (expand "exp_estimate")
            (("1" (split -1)
              (("1" (rewrite "sigma_first" -2)
                (("1" (replace -1)
                  (("1" (hide -1)
                    (("1" (lemma "nderiv_exp" ("n" "n!1+1"))
                      (("1" (flatten) (("1" (assertnil nil)) nil))
                      nil))
                    nil))
                  nil)
                 ("2" (case-replace "n!1 = 0")
                  (("1" (assert)
                    (("1" (expand "sigma")
                      (("1" (split -3)
                        (("1" (lemma "nderiv_exp")
                          (("1" (inst?)
                            (("1" (flatten)
                              (("1"
                                (replace -2)
                                (("1" (propax) nil nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (lemma "nderiv_exp")
                          (("2" (inst?) (("2" (flatten) nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (assertnil nil))
                  nil))
                nil)
               ("2" (skosimp*)
                (("2" (hide 2)
                  (("2" (hide -1)
                    (("2" (lemma "nderiv_exp")
                      (("2" (inst?)
                        (("2" (flatten)
                          (("2" (replace -2) (("2" (assertnil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (skosimp*)
          (("2" (assert)
            (("2" (hide - 4)
              (("2" (lemma "nderiv_exp")
                (("2" (inst?) (("2" (flatten) nil nil)) nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((sigma_eq formula-decl nil sigma "reals/")
    (sigma_first formula-decl nil sigma "reals/")
    (sigma def-decl "real" sigma "reals/")
    (exp_0 formula-decl nil ln_exp nil)
    (ln const-decl "real" ln_exp nil)
    (exp const-decl "{py | x = ln(py)}" ln_exp nil))
   nil))
 (exp_taylors_err_TCC1 0
  (exp_taylors_err_TCC1-1 nil 3302449689
   ("" (skosimp*) (("" (assertnil nil)) nil)
   ((nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   shostak))
 (exp_taylors_err 0
  (exp_taylors_err-2 nil 3302449661
   ("" (skosimp*)
    (("" (lemma "exp_taylors" ("x" "x!1" "n" "n!1"))
      (("" (skosimp*)
        (("" (typepred "c!1")
          (("" (lemma "trichotomy" ("x" "x!1"))
            ((""
              (case "exp(x!1) - exp_estimate(x!1, n!1) = exp(c!1) * x!1 ^ (n!1 + 1) / factorial(n!1 + 1)")
              (("1" (replace -1)
                (("1" (rewrite "abs_div" 1)
                  (("1" (expand "abs" 1 2)
                    (("1"
                      (lemma "both_sides_div_pos_le1"
                       ("x" "abs(exp(c!1) * x!1 ^ (1 + n!1))" "y"
                        "max(exp(x!1),1) * x!1 ^ (1 + n!1)" "pz"
                        "factorial(1 + n!1)"))
                      (("1" (hide -1 -2 -7)
                        (("1" (rewrite "abs_mult")
                          (("1" (expand "abs" 1 1)
                            (("1" (case "exp(c!1)<=max(exp(x!1),1)")
                              (("1"
                                (split -2)
                                (("1"
                                  (lemma
                                   "expt_pos"
                                   ("px" "x!1" "i" "1+n!1"))
                                  (("1"
                                    (expand "abs" 1)
                                    (("1"
                                      (lemma "exp_strict_increasing")
                                      (("1"
                                        (expand "strict_increasing?")
                                        (("1"
                                          (inst-cp - "0" "c!1")
                                          (("1"
                                            (inst - "c!1" "x!1")
                                            (("1"
                                              (rewrite "exp_0")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (flatten -6)
                                                  (("1"
                                                    (expand "max")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (lemma
                                                         "both_sides_times_pos_lt1"
                                                         ("x"
                                                          "exp(c!1)"
                                                          "y"
                                                          "exp(x!1)"
                                                          "pz"
                                                          "x!1^(1+n!1)"))
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (lemma
                                                             "both_sides_div_pos_lt1"
                                                             ("x"
                                                              "exp(c!1) * x!1 ^ (1 + n!1)"
                                                              "y"
                                                              "exp(x!1) * x!1 ^ (1 + n!1)"
                                                              "pz"
                                                              "factorial(1+n!1)"))
                                                            (("1"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2" (assertnil nil))
                                  nil)
                                 ("2"
                                  (replace -1)
                                  (("2"
                                    (replace -5)
                                    (("2"
                                      (rewrite "exp_0")
                                      (("2"
                                        (expand "max")
                                        (("2"
                                          (expand "^")
                                          (("2"
                                            (expand "expt")
                                            (("2"
                                              (expand "abs")
                                              (("2" (assertnil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("3"
                                  (lemma "exp_strict_increasing")
                                  (("3"
                                    (expand "strict_increasing?")
                                    (("3"
                                      (assert)
                                      (("3"
                                        (hide -4 -6)
                                        (("3"
                                          (flatten -4)
                                          (("3"
                                            (inst-cp - "x!1" "c!1")
                                            (("3"
                                              (inst - "c!1" "0")
                                              (("3"
                                                (rewrite "exp_0")
                                                (("3"
                                                  (expand "max")
                                                  (("3"
                                                    (assert)
                                                    (("3"
                                                      (typepred
                                                       "exp(c!1)")
                                                      (("3"
                                                        (hide -1 -3)
                                                        (("3"
                                                          (case
                                                           "abs(x!1 ^ (1 + n!1)) = abs(x!1) ^ (1 + n!1)")
                                                          (("1"
                                                            (lemma
                                                             "posreal_div_posreal_is_posreal"
                                                             ("px"
                                                              "abs(x!1) ^ (1 + n!1)"
                                                              "py"
                                                              "factorial(1 + n!1)"))
                                                            (("1"
                                                              (lemma
                                                               "both_sides_times_pos_le1"
                                                               ("x"
                                                                "exp(c!1)"
                                                                "y"
                                                                "1"
                                                                "pz"
                                                                "abs(x!1) ^ (1 + n!1) / factorial(1 + n!1)"))
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil)
                                                               ("2"
                                                                (propax)
                                                                nil
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (hide 2)
                                                              (("2"
                                                                (lemma
                                                                 "expt_pos"
                                                                 ("px"
                                                                  "abs(x!1)"
                                                                  "i"
                                                                  "1+n!1"))
                                                                (("1"
                                                                  (propax)
                                                                  nil
                                                                  nil)
                                                                 ("2"
                                                                  (hide
                                                                   2)
                                                                  (("2"
                                                                    (expand
                                                                     "abs")
                                                                    (("2"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (hide 2)
                                                            (("2"
                                                              (case
                                                               "FORALL (n:nat): abs(x!1^n) = abs(x!1)^n")
                                                              (("1"
                                                                (inst
                                                                 -
                                                                 "1+n!1")
                                                                nil
                                                                nil)
                                                               ("2"
                                                                (hide-all-but
                                                                 (-4
                                                                  1))
                                                                (("2"
                                                                  (induct
                                                                   "n")
                                                                  (("1"
                                                                    (rewrite
                                                                     "expt_x0")
                                                                    (("1"
                                                                      (rewrite
                                                                       "expt_x0")
                                                                      (("1"
                                                                        (expand
                                                                         "abs")
                                                                        (("1"
                                                                          (propax)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (skosimp*)
                                                                    (("2"
                                                                      (expand
                                                                       "^")
                                                                      (("2"
                                                                        (expand
                                                                         "expt"
                                                                         1)
                                                                        (("2"
                                                                          (rewrite
                                                                           "abs_mult"
                                                                           1)
                                                                          (("2"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide 2)
                                (("2"
                                  (expand "max")
                                  (("2"
                                    (lemma "exp_strict_increasing")
                                    (("2"
                                      (expand "strict_increasing?")
                                      (("2"
                                        (split -2)
                                        (("1"
                                          (assert)
                                          (("1"
                                            (flatten -3)
                                            (("1"
                                              (inst-cp - "0" "c!1")
                                              (("1"
                                                (inst - "c!1" "x!1")
                                                (("1"
                                                  (rewrite "exp_0")
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (assert)
                                          (("2"
                                            (replace -1)
                                            (("2"
                                              (replace -3)
                                              (("2"
                                                (rewrite "exp_0")
                                                (("2"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("3"
                                          (assert)
                                          (("3"
                                            (flatten -4)
                                            (("3"
                                              (inst-cp - "x!1" "c!1")
                                              (("3"
                                                (inst - "c!1" "0")
                                                (("3"
                                                  (rewrite "exp_0")
                                                  (("3"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (assertnil nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (exp_taylors formula-decl nil exp_series nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (< const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (between type-eq-decl nil taylors "analysis/")
    (factorial def-decl "posnat" factorial "ints/")
    (posnat nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (^ const-decl "real" exponentiation nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/= const-decl "boolean" notequal nil)
    (exp_estimate const-decl "real" exp_series nil)
    (exp const-decl "{py | x = ln(py)}" ln_exp nil)
    (ln const-decl "real" ln_exp nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (abs_div formula-decl nil real_props nil)
    (nzint_abs_is_pos application-judgement "{j: posint | j >= i}"
     real_defs nil)
    (nnreal_div_posreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (both_sides_div_pos_le1 formula-decl nil real_props nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (abs_mult formula-decl nil real_props nil)
    (nonzero_abs_is_pos application-judgement "{y: posreal | y >= x}"
     real_defs nil)
    (<= const-decl "bool" reals nil)
    (both_sides_times_pos_le1 formula-decl nil real_props nil)
    (posreal_div_posreal_is_posreal judgement-tcc nil real_types nil)
    (pred type-eq-decl nil defined_types nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (expt_x0 formula-decl nil exponentiation nil)
    (nnreal_expt application-judgement "nnreal" exponentiation nil)
    (nat_exp application-judgement "nat" exponentiation nil)
    (nat_expt application-judgement "nat" exponentiation nil)
    (nnrat_div_posrat_is_nnrat application-judgement "nonneg_rat"
     rationals nil)
    (expt def-decl "real" exponentiation nil)
    (int_abs_is_nonneg application-judgement "{j: nonneg_int | j >= i}"
     real_defs nil)
    (expt_pos formula-decl nil exponentiation nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (exp_strict_increasing formula-decl nil ln_exp nil)
    (exp_0 formula-decl nil ln_exp nil)
    (both_sides_div_pos_lt1 formula-decl nil real_props nil)
    (both_sides_times_pos_lt1 formula-decl nil real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (strict_increasing? const-decl "bool" real_fun_preds "reals/")
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (nnreal_times_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (nnreal_exp application-judgement "nnreal" exponentiation nil)
    (posreal_max application-judgement
     "{z: posreal | z >= x AND z >= y}" real_defs nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (trichotomy formula-decl nil real_axioms nil)
    (real_minus_real_is_real application-judgement "real" reals nil))
   nil)
  (exp_taylors_err-1 nil 3302449625
   ("" (skosimp*)
    (("" (lemma "exp_taylors" ("x" "x!1" "n" "n!1"))
      (("" (skosimp*)
        (("" (typepred "c!1")
          (("" (lemma "trichotomy" ("x" "x!1"))
            ((""
              (case "exp(x!1) - exp_series_n(x!1, n!1) = exp(c!1) * x!1 ^ (n!1 + 1) / factorial(n!1 + 1)")
              (("1" (replace -1)
                (("1" (rewrite "abs_div" 1)
                  (("1" (expand "abs" 1 2)
                    (("1"
                      (lemma "both_sides_div_pos_le1"
                       ("x" "abs(exp(c!1) * x!1 ^ (1 + n!1))" "y"
                        "max(exp(x!1),1) * x!1 ^ (1 + n!1)" "pz"
                        "factorial(1 + n!1)"))
                      (("1" (hide -1 -2 -7)
                        (("1" (rewrite "abs_mult")
                          (("1" (expand "abs" 1 1)
                            (("1" (case "exp(c!1)<=max(exp(x!1),1)")
                              (("1"
                                (split -2)
                                (("1"
                                  (lemma
                                   "expt_pos"
                                   ("px" "x!1" "i" "1+n!1"))
                                  (("1"
                                    (expand "abs" 1)
                                    (("1"
                                      (lemma "exp_strict_increasing")
                                      (("1"
                                        (expand "strict_increasing?")
                                        (("1"
                                          (inst-cp - "0" "c!1")
                                          (("1"
                                            (inst - "c!1" "x!1")
                                            (("1"
                                              (rewrite "exp_0")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (flatten -6)
                                                  (("1"
                                                    (expand "max")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (lemma
                                                         "both_sides_times_pos_lt1"
                                                         ("x"
                                                          "exp(c!1)"
                                                          "y"
                                                          "exp(x!1)"
                                                          "pz"
                                                          "x!1^(1+n!1)"))
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (lemma
                                                             "both_sides_div_pos_lt1"
                                                             ("x"
                                                              "exp(c!1) * x!1 ^ (1 + n!1)"
                                                              "y"
                                                              "exp(x!1) * x!1 ^ (1 + n!1)"
                                                              "pz"
                                                              "factorial(1+n!1)"))
                                                            (("1"
                                                              (assert)
                                                              nil)))))))))))))))))))))))))))
                                   ("2" (assertnil)))
                                 ("2"
                                  (replace -1)
                                  (("2"
                                    (replace -5)
                                    (("2"
                                      (rewrite "exp_0")
                                      (("2"
                                        (expand "max")
                                        (("2"
                                          (expand "^")
                                          (("2"
                                            (expand "expt")
                                            (("2"
                                              (expand "abs")
                                              (("2"
                                                (assert)
                                                nil)))))))))))))))
                                 ("3"
                                  (lemma "exp_strict_increasing")
                                  (("3"
                                    (expand "strict_increasing?")
                                    (("3"
                                      (assert)
                                      (("3"
                                        (hide -4 -6)
                                        (("3"
                                          (flatten -4)
                                          (("3"
                                            (inst-cp - "x!1" "c!1")
                                            (("3"
                                              (inst - "c!1" "0")
                                              (("3"
                                                (rewrite "exp_0")
                                                (("3"
                                                  (expand "max")
                                                  (("3"
                                                    (assert)
                                                    (("3"
                                                      (typepred
                                                       "exp(c!1)")
                                                      (("3"
                                                        (hide -1 -3)
                                                        (("3"
                                                          (case
                                                           "abs(x!1 ^ (1 + n!1)) = abs(x!1) ^ (1 + n!1)")
                                                          (("1"
                                                            (lemma
                                                             "posreal_div_posreal_is_posreal"
                                                             ("px"
                                                              "abs(x!1) ^ (1 + n!1)"
                                                              "py"
                                                              "factorial(1 + n!1)"))
                                                            (("1"
                                                              (lemma
                                                               "both_sides_times_pos_le1"
                                                               ("x"
                                                                "exp(c!1)"
                                                                "y"
                                                                "1"
                                                                "pz"
                                                                "abs(x!1) ^ (1 + n!1) / factorial(1 + n!1)"))
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (replace
                                                                   -3
                                                                   1)
                                                                  (("1"
                                                                    (assert)
                                                                    nil)))))
                                                               ("2"
                                                                (propax)
                                                                nil)))
                                                             ("2"
                                                              (hide 2)
                                                              (("2"
                                                                (lemma
                                                                 "expt_pos"
                                                                 ("px"
                                                                  "abs(x!1)"
                                                                  "i"
                                                                  "1+n!1"))
                                                                (("1"
                                                                  (propax)
                                                                  nil)
                                                                 ("2"
                                                                  (hide
                                                                   2)
                                                                  (("2"
                                                                    (expand
                                                                     "abs")
                                                                    (("2"
                                                                      (assert)
                                                                      nil)))))))))))
                                                           ("2"
                                                            (hide 2)
                                                            (("2"
                                                              (case
                                                               "FORALL (n:nat): abs(x!1^n) = abs(x!1)^n")
                                                              (("1"
                                                                (inst
                                                                 -
                                                                 "1+n!1")
                                                                nil)
                                                               ("2"
                                                                (hide-all-but
                                                                 (-4
                                                                  1))
                                                                (("2"
                                                                  (induct
                                                                   "n")
                                                                  (("1"
                                                                    (rewrite
                                                                     "expt_x0")
                                                                    (("1"
                                                                      (rewrite
                                                                       "expt_x0")
                                                                      (("1"
                                                                        (expand
                                                                         "abs")
                                                                        (("1"
                                                                          (propax)
                                                                          nil)))))))
                                                                   ("2"
                                                                    (skosimp*)
                                                                    (("2"
                                                                      (expand
                                                                       "^")
                                                                      (("2"
                                                                        (expand
                                                                         "expt"
                                                                         1)
                                                                        (("2"
                                                                          (rewrite
                                                                           "abs_mult"
                                                                           1)
                                                                          (("2"
                                                                            (assert)
                                                                            nil)))))))))))))))))))))))))))))))))))))))))))))
                               ("2"
                                (hide 2)
                                (("2"
                                  (expand "max")
                                  (("2"
                                    (lemma "exp_strict_increasing")
                                    (("2"
                                      (expand "strict_increasing?")
                                      (("2"
                                        (split -2)
                                        (("1"
                                          (assert)
                                          (("1"
                                            (flatten -3)
                                            (("1"
                                              (inst-cp - "0" "c!1")
                                              (("1"
                                                (inst - "c!1" "x!1")
                                                (("1"
                                                  (rewrite "exp_0")
                                                  (("1"
                                                    (assert)
                                                    nil)))))))))))
                                         ("2"
                                          (assert)
                                          (("2"
                                            (replace -1)
                                            (("2"
                                              (replace -3)
                                              (("2"
                                                (rewrite "exp_0")
                                                (("2"
                                                  (assert)
                                                  nil)))))))))
                                         ("3"
                                          (assert)
                                          (("3"
                                            (flatten -4)
                                            (("3"
                                              (inst-cp - "x!1" "c!1")
                                              (("3"
                                                (inst - "c!1" "0")
                                                (("3"
                                                  (rewrite "exp_0")
                                                  (("3"
                                                    (assert)
                                                    nil)))))))))))))))))))))))))))))))))))))
               ("2" (assertnil))))))))))))
    nil)
   nil nil))
 (exp_estimate_increasing 0
  (exp_estimate_increasing-1 nil 3559669148
   ("" (name "TT" "LAMBDA (x:real): -1<=x")
    ((""
      (case "FORALL (n:nat): FORALL (m:nat): m<=n IMPLIES increasing?(LAMBDA (x:(TT)): exp_estimate(x,m)) AND exp_estimate(-1,m)>=0")
      (("1" (skeep)
        (("1" (inst - "n")
          (("1" (inst - "n")
            (("1" (assert)
              (("1" (flatten)
                (("1" (expand "increasing?")
                  (("1" (inst - "x" "y")
                    (("1" (assertnil nil)
                     ("2" (expand "TT") (("2" (assertnil nil)) nil)
                     ("3" (expand "TT") (("3" (propax) nil nil)) nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (hide 2)
        (("2" (induct "n")
          (("1" (skeep)
            (("1" (case "m = 0")
              (("1" (replace -1)
                (("1" (assert) (("1" (grind) nil nil)) nil)) nil)
               ("2" (assertnil nil))
              nil))
            nil)
           ("2" (skeep)
            (("2" (skeep)
              (("2" (case "NOT j = m-1")
                (("1" (inst - "m") (("1" (assertnil nil)) nil)
                 ("2" (replace -1)
                  (("2" (assert)
                    (("2" (hide -3)
                      (("2" (hide -1)
                        (("2" (case "NOT exp_estimate(-1,m)>=0")
                          (("1" (hide 2)
                            (("1" (lemma "even_or_odd")
                              (("1"
                                (inst - "m")
                                (("1"
                                  (ground)
                                  (("1"
                                    (expand "even?")
                                    (("1"
                                      (skeep -1)
                                      (("1"
                                        (replaces -1)
                                        (("1"
                                          (inst - "2*j!1-1")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (flatten)
                                              (("1"
                                                (hide -1)
                                                (("1"
                                                  (expand
                                                   "exp_estimate")
                                                  (("1"
                                                    (expand "sigma" +)
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (case
                                                         "j!1 = 0")
                                                        (("1"
                                                          (replaces -1)
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (assert)
                                                          (("2"
                                                            (case
                                                             "1 > 2*j!1")
                                                            (("1"
                                                              (assert)
                                                              nil
                                                              nil)
                                                             ("2"
                                                              (assert)
                                                              (("2"
                                                                (case
                                                                 "(-1) ^ (2 * j!1) / factorial(2 * j!1) >= 0")
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil)
                                                                 ("2"
                                                                  (hide
                                                                   5)
                                                                  (("2"
                                                                    (cross-mult
                                                                     1)
                                                                    (("2"
                                                                      (lemma
                                                                       "even_m1_pow")
                                                                      (("2"
                                                                        (inst?)
                                                                        (("2"
                                                                          (assert)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (assert)
                                            (("2"
                                              (case "NOT j!1 = 0")
                                              (("1"
                                                (case "j!1 >= 1")
                                                (("1" (assertnil nil)
                                                 ("2"
                                                  (assert)
                                                  (("2"
                                                    (expand
                                                     "exp_estimate")
                                                    (("2"
                                                      (expand "sigma")
                                                      (("2"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (assert)
                                                (("2"
                                                  (replace -1)
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (expand
                                                       "exp_estimate")
                                                      (("2"
                                                        (expand
                                                         "sigma")
                                                        (("2"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (inst - "m-2")
                                    (("1"
                                      (assert)
                                      (("1"
                                        (flatten)
                                        (("1"
                                          (hide -2)
                                          (("1"
                                            (expand "odd?")
                                            (("1"
                                              (skeep -1)
                                              (("1"
                                                (case "NOT j!1 >= 0")
                                                (("1" (assertnil nil)
                                                 ("2"
                                                  (assert)
                                                  (("2"
                                                    (replaces -2)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (expand
                                                         "exp_estimate")
                                                        (("2"
                                                          (expand
                                                           "sigma"
                                                           +)
                                                          (("2"
                                                            (expand
                                                             "sigma"
                                                             +)
                                                            (("2"
                                                              (assert)
                                                              (("2"
                                                                (case
                                                                 "j!1 = 0")
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (replaces
                                                                     -1)
                                                                    (("1"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (assert)
                                                                  (("2"
                                                                    (case
                                                                     "-((-1) ^ (1 + 2 * j!1)) / factorial(1 + 2 * j!1)
       <= (-1) ^ (2 * j!1) / factorial(2 * j!1)")
                                                                    (("1"
                                                                      (assert)
                                                                      nil
                                                                      nil)
                                                                     ("2"
                                                                      (hide
                                                                       4)
                                                                      (("2"
                                                                        (hide
                                                                         -2)
                                                                        (("2"
                                                                          (lemma
                                                                           "even_m1_pow")
                                                                          (("2"
                                                                            (inst
                                                                             -
                                                                             "2*j!1")
                                                                            (("2"
                                                                              (assert)
                                                                              (("2"
                                                                                (replaces
                                                                                 -1)
                                                                                (("2"
                                                                                  (lemma
                                                                                   "not_even_m1_pow")
                                                                                  (("2"
                                                                                    (inst
                                                                                     -
                                                                                     "1+2*j!1")
                                                                                    (("2"
                                                                                      (assert)
                                                                                      (("2"
                                                                                        (replaces
                                                                                         -1)
                                                                                        (("2"
                                                                                          (assert)
                                                                                          (("2"
                                                                                            (cross-mult
                                                                                             1)
                                                                                            (("2"
                                                                                              (typepred
                                                                                               "factorial(2*j!1)")
                                                                                              (("2"
                                                                                                (mult-by
                                                                                                 -1
                                                                                                 "2*j!1")
                                                                                                (("2"
                                                                                                  (expand
                                                                                                   "factorial"
                                                                                                   +
                                                                                                   2)
                                                                                                  (("2"
                                                                                                    (assert)
                                                                                                    nil
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (assert)
                                      (("2"
                                        (case "m = 0")
                                        (("1"
                                          (replaces -1)
                                          (("1"
                                            (hide -)
                                            (("1" (grind) nil nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (case "m = 1")
                                          (("1"
                                            (replaces -1)
                                            (("1"
                                              (hide -)
                                              (("1" (grind) nil nil))
                                              nil))
                                            nil)
                                           ("2" (assertnil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (assert)
                            (("2" (lemma "poly_increasing")
                              (("2"
                                (expand "increasing?")
                                (("2"
                                  (skosimp*)
                                  (("2"
                                    (inst - "exp_seq" "m" "x!1" "y!1")
                                    (("2"
                                      (assert)
                                      (("2"
                                        (case
                                         "polynomial(exp_seq,m) = LAMBDA (gg:real): exp_estimate(gg,m)")
                                        (("1"
                                          (replace -1)
                                          (("1"
                                            (assert)
                                            (("1"
                                              (hide 2)
                                              (("1"
                                                (skosimp*)
                                                (("1"
                                                  (inst - "m-1")
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (flatten)
                                                      (("1"
                                                        (inst
                                                         -
                                                         "-1"
                                                         "c!1")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (typepred
                                                             "x!1")
                                                            (("1"
                                                              (expand
                                                               "TT")
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (case
                                                                   "polynomial(poly_deriv(exp_seq),m-1) = LAMBDA (gg:real): exp_estimate(gg,m-1)")
                                                                  (("1"
                                                                    (replace
                                                                     -1)
                                                                    (("1"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (hide-all-but
                                                                     1)
                                                                    (("2"
                                                                      (decompose-equality)
                                                                      (("2"
                                                                        (expand
                                                                         "exp_estimate")
                                                                        (("2"
                                                                          (expand
                                                                           "polynomial")
                                                                          (("2"
                                                                            (lemma
                                                                             "sigma_split")
                                                                            (("2"
                                                                              (inst?)
                                                                              (("2"
                                                                                (inst
                                                                                 -
                                                                                 "0")
                                                                                (("2"
                                                                                  (assert)
                                                                                  (("2"
                                                                                    (replace
                                                                                     -1)
                                                                                    (("2"
                                                                                      (hide
                                                                                       -1)
                                                                                      (("2"
                                                                                        (case
                                                                                         "FORALL (a1,a2,b1,b2:real): a1=b1 AND a2=b2 IMPLIEs a1+a2 = b1+b2")
                                                                                        (("1"
                                                                                          (rewrite
                                                                                           -1)
                                                                                          (("1"
                                                                                            (hide-all-but
                                                                                             1)
                                                                                            (("1"
                                                                                              (grind)
                                                                                              nil
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (hide-all-but
                                                                                             1)
                                                                                            (("2"
                                                                                              (rewrite
                                                                                               "sigma_eq")
                                                                                              (("2"
                                                                                                (hide
                                                                                                 2)
                                                                                                (("2"
                                                                                                  (skosimp*)
                                                                                                  (("2"
                                                                                                    (expand
                                                                                                     "exp_seq")
                                                                                                    (("2"
                                                                                                      (expand
                                                                                                       "poly_deriv")
                                                                                                      (("2"
                                                                                                        (case
                                                                                                         "(1+n!1)/factorial(1+n!1) = 1/factorial(n!1)")
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          nil
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (hide
                                                                                                           2)
                                                                                                          (("2"
                                                                                                            (expand
                                                                                                             "factorial"
                                                                                                             +
                                                                                                             1)
                                                                                                            (("2"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (skosimp*)
                                                                                          (("2"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (expand "TT")
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (typepred
                                                               "x!1")
                                                              (("2"
                                                                (expand
                                                                 "TT")
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("3"
                                                          (expand "TT")
                                                          (("3"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (hide-all-but 1)
                                          (("2"
                                            (decompose-equality)
                                            (("2"
                                              (expand "polynomial")
                                              (("2"
                                                (lemma "sigma_split")
                                                (("2"
                                                  (inst?)
                                                  (("2"
                                                    (inst - "0")
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (replaces -1)
                                                        (("2"
                                                          (expand
                                                           "exp_estimate")
                                                          (("2"
                                                            (case
                                                             "FORALL (a1,a2,b1,b2:real): a1=b1 AND a2=b2 IMPLIEs a1+a2 = b1+b2")
                                                            (("1"
                                                              (rewrite
                                                               -1)
                                                              (("1"
                                                                (hide-all-but
                                                                 1)
                                                                (("1"
                                                                  (grind)
                                                                  nil
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (hide-all-but
                                                                 1)
                                                                (("2"
                                                                  (rewrite
                                                                   "sigma_eq")
                                                                  (("2"
                                                                    (hide
                                                                     2)
                                                                    (("2"
                                                                      (skosimp*)
                                                                      (("2"
                                                                        (expand
                                                                         "exp_seq")
                                                                        (("2"
                                                                          (assert)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (hide 2)
                                                              (("2"
                                                                (skosimp*)
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((exp_estimate const-decl "real" exp_series nil)
    (increasing? const-decl "bool" real_fun_preds "reals/")
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (y skolem-const-decl "real" exp_series nil)
    (x skolem-const-decl "real" exp_series nil)
    (TT skolem-const-decl "[real -> bool]" exp_series nil)
    (pred type-eq-decl nil defined_types nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (^ const-decl "real" exponentiation nil)
    (sigma def-decl "real" sigma "reals/")
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nzrat_div_nzrat_is_nzrat application-judgement "nzrat" rationals
     nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (even_or_odd formula-decl nil naturalnumbers nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (j!1 skolem-const-decl "int" exp_series nil)
    (int_exp application-judgement "int" exponentiation nil)
    (nzreal_exp application-judgement "nzreal" exponentiation nil)
    (even_m1_pow formula-decl nil exponentiation nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (div_mult_pos_ge1 formula-decl nil real_props nil)
    (factorial def-decl "posnat" factorial "ints/")
    (posnat nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/= const-decl "boolean" notequal nil)
    (> const-decl "bool" reals nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (rat_exp application-judgement "rat" exponentiation nil)
    (even? const-decl "bool" integers nil)
    (int_expt application-judgement "int" exponentiation nil)
    (nzreal_expt application-judgement "nzreal" exponentiation nil)
    (expt def-decl "real" exponentiation nil)
    (even_minus_even_is_even application-judgement "even_int" integers
     nil)
    (odd_minus_even_is_odd application-judgement "odd_int" integers
     nil)
    (not_even_m1_pow formula-decl nil exponentiation nil)
    (posrat_div_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (int_times_even_is_even application-judgement "even_int" integers
     nil)
    (both_sides_times_pos_gt1 formula-decl nil real_props nil)
    (nzint_times_nzint_is_nzint application-judgement "nzint" integers
     nil)
    (div_mult_pos_le2 formula-decl nil real_props nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (times_div2 formula-decl nil real_props nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (div_mult_pos_le1 formula-decl nil real_props nil)
    (minus_nzrat_is_nzrat application-judgement "nzrat" rationals nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (expt_x1 formula-decl nil exponentiation nil)
    (factorial_1 formula-decl nil factorial "ints/")
    (rat_plus_rat_is_rat application-judgement "rat" rationals nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (odd? const-decl "bool" integers nil)
    (m skolem-const-decl "nat" exp_series nil)
    (poly_increasing formula-decl nil polynomials "reals/")
    (poly_deriv const-decl "real" polynomials "reals/")
    (real_times_real_is_real application-judgement "real" reals nil)
    (T_low type-eq-decl nil sigma "reals/")
    (T_high type-eq-decl nil sigma "reals/")
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nnrat_times_nnrat_is_nnrat application-judgement "nonneg_rat"
     rationals nil)
    (posrat_times_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (posrat_plus_nnrat_is_posrat application-judgement "posrat"
     rationals nil)
    (sigma_eq formula-decl nil sigma "reals/")
    (subrange type-eq-decl nil integers nil)
    (rat_div_nzrat_is_rat application-judgement "rat" rationals nil)
    (sigma_split formula-decl nil sigma "reals/")
    (c!1 skolem-const-decl "real" exp_series nil)
    (polynomial const-decl "[real -> real]" polynomials "reals/")
    (sequence type-eq-decl nil sequences nil)
    (exp_seq const-decl "real" exp_series nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (<= const-decl "bool" reals nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield -> numfield]" number_fields nil))
   shostak))
 (exp_estimate_positive 0
  (exp_estimate_positive-1 nil 3568453550
   ("" (case "FORALL (m:posnat): exp_estimate(-1,m)>=0")
    (("1"
      (case "FORALL (m:posnat): m>1 IMPLIES exp_estimate(-1,m) > 0")
      (("1" (skeep)
        (("1" (inst - "n")
          (("1" (assert)
            (("1" (lemma "exp_estimate_increasing")
              (("1" (inst - "n" "-1" "x") (("1" (assertnil nil))
                nil))
              nil))
            nil)
           ("2" (assertnil nil))
          nil))
        nil)
       ("2" (hide 2)
        (("2" (copy -1)
          (("2" (skeep)
            (("2" (inst - "m")
              (("2" (case "NOT exp_estimate(-1,m) = 0")
                (("1" (assertnil nil)
                 ("2" (hide (-2 1))
                  (("2" (lemma "even_or_odd")
                    (("2" (inst - "m")
                      (("2" (ground)
                        (("1" (expand "even?")
                          (("1" (skeep -1)
                            (("1" (replaces -1)
                              (("1"
                                (assert)
                                (("1"
                                  (inst - "2*j-1")
                                  (("1"
                                    (assert)
                                    (("1"
                                      (expand "exp_estimate")
                                      (("1"
                                        (expand "sigma" - 1)
                                        (("1"
                                          (case
                                           "(-1) ^ (2 * j) / factorial(2 * j) > 0")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (name
                                               "rd"
                                               "1 + sigma(1, 2 * j - 1, LAMBDA (nn: nat): (-1) ^ nn / factorial(nn))")
                                              (("1"
                                                (replaces -1)
                                                (("1"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (cross-mult 1)
                                            (("2"
                                              (lemma "even_m1_pow")
                                              (("2"
                                                (inst - "2*j")
                                                (("2"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (expand "odd?")
                          (("2" (skeep -1)
                            (("2" (case "NOT j >= 1")
                              (("1"
                                (case "j = 1")
                                (("1"
                                  (replaces -1)
                                  (("1"
                                    (replaces -1)
                                    (("1" (assertnil nil))
                                    nil))
                                  nil)
                                 ("2" (assertnil nil))
                                nil)
                               ("2"
                                (inst - "m-2")
                                (("1"
                                  (expand "exp_estimate")
                                  (("1"
                                    (expand "sigma" - 1)
                                    (("1"
                                      (expand "sigma" - 1)
                                      (("1"
                                        (name
                                         "aa"
                                         "1 + sigma(1, m - 2, LAMBDA (nn: nat): (-1) ^ nn / factorial(nn))")
                                        (("1"
                                          (replaces -1)
                                          (("1"
                                            (case
                                             "((-1) ^ (m - 1)) / factorial(m - 1) > (-(-1) ^ m) / factorial(m)")
                                            (("1" (assertnil nil)
                                             ("2"
                                              (lemma "even_m1_pow")
                                              (("2"
                                                (replaces -3)
                                                (("2"
                                                  (assert)
                                                  (("2"
                                                    (inst - "2*j")
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (replaces -1)
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (lemma
                                                             "not_even_m1_pow")
                                                            (("2"
                                                              (inst
                                                               -
                                                               "1+2*j")
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (replaces
                                                                   -1)
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (cross-mult
                                                                       1)
                                                                      (("2"
                                                                        (mult-by
                                                                         -3
                                                                         "factorial(2*j)")
                                                                        (("2"
                                                                          (expand
                                                                           "factorial"
                                                                           +
                                                                           1)
                                                                          (("2"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2" (assertnil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil)
     ("2" (hide 2)
      (("2"
        (case "FORALL (mm: nat): FORALL (kk:nat): kk<=mm IMPLIES exp_estimate(-1, kk) >= 0")
        (("1" (skeep)
          (("1" (inst - "m")
            (("1" (inst - "m") (("1" (assertnil nil)) nil)) nil))
          nil)
         ("2" (hide 2)
          (("2" (induct "mm")
            (("1" (grind) nil nil)
             ("2" (skeep)
              (("2" (skeep)
                (("2" (case "NOT kk = j+1")
                  (("1" (inst - "kk") (("1" (assertnil nil)) nil)
                   ("2" (hide -3)
                    (("2" (assert)
                      (("2" (assert)
                        (("2" (replaces -1)
                          (("2" (case "j = 0")
                            (("1" (replaces -1)
                              (("1"
                                (hide -)
                                (("1" (grind) nil nil))
                                nil))
                              nil)
                             ("2" (lemma "even_or_odd")
                              (("2"
                                (inst - "1+j")
                                (("2"
                                  (ground)
                                  (("1"
                                    (expand "even?")
                                    (("1"
                                      (skosimp*)
                                      (("1"
                                        (inst - "2*j!1-1")
                                        (("1"
                                          (assert)
                                          (("1"
                                            (replaces -1)
                                            (("1"
                                              (expand "exp_estimate")
                                              (("1"
                                                (expand "sigma" +)
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (case
                                                     "(-1) ^ (2 * j!1) / factorial(2 * j!1) >= 0")
                                                    (("1"
                                                      (assert)
                                                      nil
                                                      nil)
                                                     ("2"
                                                      (cross-mult 1)
                                                      (("2"
                                                        (lemma
                                                         "even_m1_pow")
                                                        (("2"
                                                          (inst?)
                                                          (("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2" (assertnil nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (expand "odd?")
                                    (("2"
                                      (skosimp*)
                                      (("2"
                                        (inst - "j-1")
                                        (("2"
                                          (replaces -1)
                                          (("2"
                                            (assert)
                                            (("2"
                                              (expand "exp_estimate")
                                              (("2"
                                                (expand "sigma" +)
                                                (("2"
                                                  (case "1> 1+2*j!1")
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil)
                                                   ("2"
                                                    (assert)
                                                    (("2"
                                                      (expand
                                                       "sigma"
                                                       +)
                                                      (("2"
                                                        (assert)
                                                        (("2"
                                                          (case
                                                           "-((-1) ^ (1 + 2 * j!1)) / factorial(1 + 2 * j!1)
       < (-1) ^ (2 * j!1) / factorial(2 * j!1)")
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil)
                                                           ("2"
                                                            (hide
                                                             (-1 5))
                                                            (("2"
                                                              (lemma
                                                               "even_m1_pow")
                                                              (("2"
                                                                (inst
                                                                 -
                                                                 "2*j!1")
                                                                (("2"
                                                                  (assert)
                                                                  (("2"
                                                                    (replaces
                                                                     -1)
                                                                    (("2"
                                                                      (lemma
                                                                       "not_even_m1_pow")
                                                                      (("2"
                                                                        (inst?)
                                                                        (("2"
                                                                          (assert)
                                                                          (("2"
                                                                            (replaces
                                                                             -1)
                                                                            (("2"
                                                                              (cross-mult
                                                                               1)
                                                                              (("2"
                                                                                (case
                                                                                 "1+2*j!1 > 1")
                                                                                (("1"
                                                                                  (mult-by
                                                                                   -1
                                                                                   "factorial(2*j!1)")
                                                                                  (("1"
                                                                                    (expand
                                                                                     "factorial"
                                                                                     +
                                                                                     2)
                                                                                    (("1"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (div_mult_pos_ge1 formula-decl nil real_props nil)
    (j!1 skolem-const-decl "int" exp_series nil)
    (< const-decl "bool" reals nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (div_mult_pos_lt1 formula-decl nil real_props nil)
    (div_mult_pos_lt2 formula-decl nil real_props nil)
    (expt def-decl "real" exponentiation nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nzreal_expt application-judgement "nzreal" exponentiation nil)
    (int_expt application-judgement "int" exponentiation nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (n skolem-const-decl "nat" exp_series nil)
    (exp_estimate_increasing formula-decl nil exp_series nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (odd? const-decl "bool" integers nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (minus_nzrat_is_nzrat application-judgement "nzrat" rationals nil)
    (posrat_div_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (nzint_times_nzint_is_nzint application-judgement "nzint" integers
     nil)
    (times_div2 formula-decl nil real_props nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (div_mult_pos_gt2 formula-decl nil extra_real_props nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (both_sides_times_pos_gt1 formula-decl nil real_props nil)
    (not_even_m1_pow formula-decl nil exponentiation nil)
    (minus_nzint_is_nzint application-judgement "nzint" integers nil)
    (m skolem-const-decl "posnat" exp_series nil)
    (even? const-decl "bool" integers nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (int_exp application-judgement "int" exponentiation nil)
    (nzreal_exp application-judgement "nzreal" exponentiation nil)
    (nzrat_div_nzrat_is_nzrat application-judgement "nzrat" rationals
     nil)
    (/= const-decl "boolean" notequal nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (^ const-decl "real" exponentiation nil)
    (factorial def-decl "posnat" factorial "ints/")
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (<= const-decl "bool" reals nil)
    (T_low type-eq-decl nil sigma "reals/")
    (T_high type-eq-decl nil sigma "reals/")
    (rat_minus_rat_is_rat application-judgement "rat" rationals nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (rat_plus_rat_is_rat application-judgement "rat" rationals nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (even_m1_pow formula-decl nil exponentiation nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (div_mult_pos_gt1 formula-decl nil extra_real_props nil)
    (sigma def-decl "real" sigma "reals/")
    (rat_exp application-judgement "rat" exponentiation nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (even_or_odd formula-decl nil naturalnumbers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (exp_estimate const-decl "real" exp_series nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield -> numfield]" number_fields nil))
   shostak))
 (exp_estimate_0 0
  (exp_estimate_0-1 nil 3568629731
   ("" (induct "n")
    (("1" (grind) nil nil)
     ("2" (skeep)
      (("2" (expand "exp_estimate")
        (("2" (expand "sigma" +) (("2" (assertnil nil)) nil)) nil))
      nil))
    nil)
   ((nnreal_plus_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (hat_02n formula-decl nil power_series "series/")
    (nat_exp application-judgement "nat" exponentiation nil)
    (^ const-decl "real" exponentiation nil)
    (sigma def-decl "real" sigma "reals/")
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nnrat_div_posrat_is_nnrat application-judgement "nonneg_rat"
     rationals nil)
    (sigma_nnreal application-judgement "nnreal" sigma_nat "reals/")
    (posreal_plus_nnreal_is_posreal application-judgement "posreal"
     real_types nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (exp_estimate const-decl "real" exp_series nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak)))


Messung V0.5 in Prozent
C=100 H=100 G=100

¤ Diese beiden folgenden Angebotsgruppen bietet das Unternehmen0.263Angebot  (Wie Sie bei der Firma Beratungs- und Dienstleistungen beauftragen können 2026-04-29) ¤

*Eine klare Vorstellung vom Zielzustand






Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.






                                                                                                                                                                                                                                                                                                                                                                                                     


Neuigkeiten

     Aktuelles
     Motto des Tages

Software

     Produkte
     Quellcodebibliothek

Aktivitäten

     Artikel über Sicherheit
     Anleitung zur Aktivierung von SSL

Muße

     Gedichte
     Musik
     Bilder

Jenseits des Üblichen ....

Besucherstatistik

Besucherstatistik

Monitoring

Montastic status badge