Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/PVS/series/   (Beweissystem der NASA Version 6.0.9©)  Datei vom 28.9.2014 mit Größe 859 kB image not shown  

SSL power_series_deriv_scaf.prf

  Sprache: Lisp
 

(power_series_deriv_scaf
 (deriv_domain 0
  (deriv_domain-1 nil 3471698080
   ("" (lemma "connected_domain")
    (("" (lemma "not_one_element")
      (("" (lemma "connected_deriv_domain[T]") (("" (assertnil nil))
        nil))
      nil))
    nil)
   ((not_one_element formula-decl nil power_series_deriv_scaf nil)
    (connected_deriv_domain formula-decl nil deriv_domain_def
     "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)
    (T_pred const-decl "[real -> boolean]" power_series_deriv_scaf nil)
    (T formal-subtype-decl nil power_series_deriv_scaf nil)
    (connected_domain formula-decl nil power_series_deriv_scaf nil))
   shostak))
 (IMP_power_series_derivseq_TCC1 0
  (IMP_power_series_derivseq_TCC1-1 nil 3299583481
   ("" (lemma "connected_domain") (("" (propax) nil nil)) nil)
   ((connected_domain formula-decl nil power_series_deriv_scaf nil))
   shostak))
 (IMP_power_series_derivseq_TCC2 0
  (IMP_power_series_derivseq_TCC2-1 nil 3299583481
   ("" (lemma "not_one_element") (("" (propax) nil nil)) nil)
   ((not_one_element formula-decl nil power_series_deriv_scaf nil))
   shostak))
 (IMP_power_series_derivseq_TCC3 0
  (IMP_power_series_derivseq_TCC3-1 nil 3299583481
   ("" (lemma "open") (("" (propax) nil nil)) nil)
   ((open formula-decl nil power_series_deriv_scaf nil)) shostak))
 (IMP_power_series_derivseq_TCC4 0
  (IMP_power_series_derivseq_TCC4-1 nil 3299583481
   ("" (lemma "ball")
    (("" (skosimp*) (("" (inst?) (("" (assertnil nil)) nil)) nil))
    nil)
   ((minus_real_is_real application-judgement "real" reals nil)
    (T formal-subtype-decl nil power_series_deriv_scaf nil)
    (T_pred const-decl "[real -> boolean]" power_series_deriv_scaf 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)
    (ball formula-decl nil power_series_deriv_scaf nil))
   shostak))
 (GET_tk_prep_TCC1 0
  (GET_tk_prep_TCC1-1 nil 3298801888
   ("" (skosimp*) (("" (assertnil nil)) nil)
   ((real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_plus_real_is_real application-judgement "real" reals nil))
   shostak))
 (GET_tk_prep_TCC2 0
  (GET_tk_prep_TCC2-1 nil 3298801888
   ("" (skosimp*) (("" (assertnil nil)) nil)
   ((real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   shostak))
 (GET_tk_prep_TCC3 0
  (GET_tk_prep_TCC3-1 nil 3298801888
   ("" (skosimp*) (("" (assertnil nil)) nil)
   ((int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   shostak))
 (GET_tk_prep 0
  (GET_tk_prep-1 nil 3298801536
   ("" (skosimp*)
    (("" (expand "nonempty?")
      (("" (expand "empty?")
        (("" (expand "member")
          (("" (lemma "mean_value[T]")
            (("1" (inst - "x!1" "x!1 + h!1" "(LAMBDA (x:T): x^k!1)")
              (("1" (assert)
                (("1" (lemma "deriv_x_to_n[T]")
                  (("1" (inst - "k!1" "1")
                    (("1" (assert)
                      (("1" (flatten)
                        (("1" (assert)
                          (("1" (split -3)
                            (("1" (skosimp*)
                              (("1"
                                (inst -6 "c!1")
                                (("1"
                                  (assert)
                                  (("1"
                                    (case-replace
                                     "(LAMBDA (x: T): 1 * x ^ k!1) = (LAMBDA (x: T): x ^ k!1)")
                                    (("1"
                                      (hide -1)
                                      (("1"
                                        (case
                                         "deriv(LAMBDA (x: T): x ^ k!1)(c!1) =
                          (LAMBDA (x: T): x ^ (k!1 - 1) * k!1)(c!1)")
                                        (("1"
                                          (expand "deriv" -1)
                                          (("1"
                                            (replace -1)
                                            (("1" (assertnil nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (hide 2)
                                          (("2"
                                            (assert)
                                            (("2"
                                              (replace -5)
                                              (("2" (assertnil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (apply-extensionality 1 :hide? t)
                                      nil
                                      nil))
                                    nil))
                                  nil)
                                 ("2" (assertnil nil))
                                nil))
                              nil)
                             ("2" (assert)
                              (("2"
                                (lemma "mean_value[T]")
                                (("2"
                                  (inst
                                   -
                                   "x!1+h!1"
                                   "x!1"
                                   "(LAMBDA (x:T): x^k!1)")
                                  (("1"
                                    (assert)
                                    (("1"
                                      (skosimp*)
                                      (("1"
                                        (inst -6 "c!1")
                                        (("1"
                                          (assert)
                                          (("1"
                                            (case-replace
                                             "(LAMBDA (x: T): 1 * x ^ k!1) = (LAMBDA (x: T): x ^ k!1)")
                                            (("1"
                                              (hide -1)
                                              (("1"
                                                (case
                                                 "deriv(LAMBDA (x: T): x ^ k!1)(c!1) =
                                           (LAMBDA (x: T): x ^ (k!1 - 1) * k!1)(c!1)")
                                                (("1"
                                                  (expand "deriv" -1)
                                                  (("1"
                                                    (replace -1)
                                                    (("1"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (hide 2)
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (replace -5)
                                                      (("2"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (apply-extensionality
                                               1
                                               :hide?
                                               t)
                                              nil
                                              nil))
                                            nil))
                                          nil)
                                         ("2" (assertnil nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (typepred "h!1")
                                    (("2"
                                      (expand "A")
                                      (("2" (propax) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (lemma "deriv_domain[T]")
                    (("2" (propax) nil nil)) nil))
                  nil))
                nil)
               ("2" (assert)
                (("2" (typepred "h!1")
                  (("2" (expand "A") (("2" (propax) nil nil)) nil))
                  nil))
                nil))
              nil)
             ("2" (lemma "not_one_element") (("2" (propax) nil nil))
              nil)
             ("3" (lemma "connected_domain") (("3" (propax) nil nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((real_minus_real_is_real application-judgement "real" reals nil)
    (nonempty? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil)
    (connected_domain formula-decl nil power_series_deriv_scaf nil)
    (not_one_element formula-decl nil power_series_deriv_scaf nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (h!1 skolem-const-decl "(A(x!1))" power_series_deriv_scaf nil)
    (x!1 skolem-const-decl "T" power_series_deriv_scaf nil)
    (A const-decl "setof[nzreal]" derivatives_def "analysis/")
    (setof type-eq-decl nil defined_types nil)
    (nzreal nonempty-type-eq-decl nil reals nil)
    (/= const-decl "boolean" notequal nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields 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)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (>= const-decl "bool" reals nil)
    (^ const-decl "real" exponentiation nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (deriv_x_to_n formula-decl nil derivatives "analysis/")
    (deriv_domain? const-decl "bool" deriv_domain_def "analysis/")
    (real_times_real_is_real application-judgement "real" reals nil)
    (c!1 skolem-const-decl "T" power_series_deriv_scaf nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (deriv const-decl "[T -> real]" derivatives "analysis/")
    (deriv_fun type-eq-decl nil derivatives "analysis/")
    (derivable? const-decl "bool" derivatives "analysis/")
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (between type-eq-decl nil taylors "analysis/")
    (c!1 skolem-const-decl "T" power_series_deriv_scaf nil)
    (< const-decl "bool" reals nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (deriv_domain formula-decl nil power_series_deriv_scaf nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (not_one_element? const-decl "bool" deriv_domain_def "analysis/")
    (connected? const-decl "bool" deriv_domain_def "analysis/")
    (mean_value formula-decl nil derivative_props "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)
    (T_pred const-decl "[real -> boolean]" power_series_deriv_scaf nil)
    (T formal-subtype-decl nil power_series_deriv_scaf nil)
    (empty? const-decl "bool" sets nil))
   shostak))
 (GET_tk_TCC1 0
  (GET_tk_TCC1-1 nil 3298736072
   (""
    (inst + "(LAMBDA (d: [x: T, (A[T](x)), posnat]):
                        choose({tk: between[T](d`1, d`1 + d`2) |
                                      ((d`1 + d`2) ^ d`3 - d`1 ^ d`3) / d`2 =
                                       d`3 * tk ^ (d`3 - 1)}))")
    (("1" (skosimp*)
      (("1" (lemma "GET_tk_prep") (("1" (inst?) nil nil)) nil)) nil)
     ("2" (skosimp*) (("2" (assertnil nil)) nil)
     ("3" (skosimp*) (("3" (assertnil nil)) nil)
     ("4" (skosimp*) (("4" (assertnil nil)) nil)
     ("5" (skosimp*)
      (("5" (lemma "not_one_element") (("5" (inst?) nil nil)) nil))
      nil)
     ("6" (skosimp*)
      (("6" (lemma "connected_domain")
        (("6" (inst?) (("6" (inst?) (("6" (assertnil nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (GET_tk_prep formula-decl nil power_series_deriv_scaf nil)
    (choose const-decl "(p)" sets nil)
    (nonempty? const-decl "bool" sets nil)
    (set type-eq-decl nil sets 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)
    (between type-eq-decl nil taylors "analysis/")
    (= const-decl "[T, T -> boolean]" equalities nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (< const-decl "bool" reals nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers 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)
    (A const-decl "setof[nzreal]" derivatives_def "analysis/")
    (setof type-eq-decl nil defined_types nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (T_pred const-decl "[real -> boolean]" power_series_deriv_scaf nil)
    (nzreal nonempty-type-eq-decl nil reals nil)
    (/= const-decl "boolean" notequal 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)
    (T formal-subtype-decl nil power_series_deriv_scaf nil)
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (int_minus_int_is_int application-judgement "int" integers nil))
   shostak))
 (Gseq_TCC1 0
  (Gseq_TCC1-1 nil 3298736072 ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers 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)
    (T_pred const-decl "[real -> boolean]" power_series_deriv_scaf nil)
    (T formal-subtype-decl nil power_series_deriv_scaf nil)
    (/= const-decl "boolean" notequal nil)
    (nzreal nonempty-type-eq-decl nil reals nil)
    (setof type-eq-decl nil defined_types nil)
    (A const-decl "setof[nzreal]" derivatives_def "analysis/")
    (>= const-decl "bool" 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)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_plus_real_is_real application-judgement "real" reals nil))
   shostak))
 (Gseq_TCC2 0
  (Gseq_TCC2-1 nil 3298736073 ("" (subtype-tcc) nil nil)
   ((real_minus_real_is_real application-judgement "real" reals nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers 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)
    (T_pred const-decl "[real -> boolean]" power_series_deriv_scaf nil)
    (T formal-subtype-decl nil power_series_deriv_scaf nil)
    (nzreal nonempty-type-eq-decl nil reals nil)
    (setof type-eq-decl nil defined_types nil)
    (A const-decl "setof[nzreal]" derivatives_def "analysis/")
    (>= const-decl "bool" 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)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (/= const-decl "boolean" notequal nil))
   shostak))
 (Gseq_TCC3 0
  (Gseq_TCC3-1 nil 3298801889
   ("" (skosimp*) (("" (assertnil nil)) nil)
   ((int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_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))
   shostak))
 (conv_scaf0_TCC1 0
  (conv_scaf0_TCC1-1 nil 3298999556
   ("" (skosimp*) (("" (assertnil nil)) nil)
   ((int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_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))
   shostak))
 (conv_scaf0 0
  (conv_scaf0-3 nil 3352091397
   ("" (skosimp*)
    (("" (lemma "conv_series_shift")
      (("" (inst?)
        (("1" (inst - "2")
          (("1" (assert)
            (("1" (hide 2)
              (("1" (lemma "derivseq_conv")
                (("1" (inst - "a!1" "_")
                  (("1" (replace -2)
                    (("1" (lemma "derivseq_conv")
                      (("1" (inst - "derivseq(a!1)" "_")
                        (("1"
                          (case-replace
                           "conv_powerseries?(derivseq(a!1))")
                          (("1" (expand "derivseq")
                            (("1" (expand "powerseq")
                              (("1"
                                (lemma "powerseries_abs_conv")
                                (("1"
                                  (expand "powerseries")
                                  (("1"
                                    (expand "powerseq")
                                    (("1"
                                      (name
                                       "NP2NP1"
                                       "(LAMBDA n: (n+2)*(n+1))")
                                      (("1"
                                        (inst
                                         -
                                         "(LAMBDA n: NP2NP1(n)*a!1(2 + n))")
                                        (("1"
                                          (expand "abs" -2)
                                          (("1"
                                            (split -2)
                                            (("1"
                                              (inst - "x!1")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (case-replace
                                                   "(LAMBDA (n: nat): abs(NP2NP1(n) * a!1(2 + n) * x!1 ^ n))
                  = (LAMBDA n:
                                          abs(a!1(2 + n)) * abs(x!1 ^ n) * abs(1 + n) *
                                           abs(2 + n))")
                                                  (("1"
                                                    (apply-extensionality
                                                     1
                                                     :hide?
                                                     t)
                                                    (("1"
                                                      (hide 2)
                                                      (("1"
                                                        (replace
                                                         -2
                                                         +
                                                         rl)
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (hide -1)
                                                            (("1"
                                                              (rewrite
                                                               "abs_mult"
                                                               :dir
                                                               rl)
                                                              (("1"
                                                                (rewrite
                                                                 "abs_mult"
                                                                 :dir
                                                                 rl)
                                                                (("1"
                                                                  (rewrite
                                                                   "abs_mult"
                                                                   :dir
                                                                   rl)
                                                                  (("1"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (hide 2)
                                                      (("2"
                                                        (skosimp*)
                                                        (("2"
                                                          (replace
                                                           -2
                                                           +
                                                           rl)
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (hide -)
                                                              (("2"
                                                                (rewrite
                                                                 "abs_mult"
                                                                 :dir
                                                                 rl)
                                                                (("2"
                                                                  (rewrite
                                                                   "abs_mult"
                                                                   :dir
                                                                   rl)
                                                                  (("2"
                                                                    (rewrite
                                                                     "abs_mult"
                                                                     :dir
                                                                     rl)
                                                                    (("2"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (hide 2)
                                              (("2"
                                                (skosimp*)
                                                (("2"
                                                  (hide -4)
                                                  (("2"
                                                    (inst -3 "x!2")
                                                    (("2"
                                                      (case-replace
                                                       "(LAMBDA (k: nat):
                          2 * (a!1(2 + k) * x!2 ^ k) +
                           3 * (k * a!1(2 + k) * x!2 ^ k)
                           + k * k * a!1(2 + k) * x!2 ^ k)
                     = (LAMBDA (k: nat): NP2NP1(k) * a!1(2 + k) * x!2 ^ k
                                  )")
                                                      (("2"
                                                        (hide 2)
                                                        (("2"
                                                          (apply-extensionality
                                                           1
                                                           :hide?
                                                           t)
                                                          (("2"
                                                            (replace
                                                             -1
                                                             +
                                                             rl)
                                                            (("2"
                                                              (hide -)
                                                              (("2"
                                                                (assert)
                                                                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 "conv_powerseries?")
                              (("2"
                                (skosimp*)
                                (("2"
                                  (hide -1)
                                  (("2"
                                    (expand "powerseries")
                                    (("2" (inst?) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (skosimp*) (("2" (assertnil nil)) nil))
        nil))
      nil))
    nil)
   ((conv_series_shift formula-decl nil series nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (conv_powerseries? const-decl "bool" power_series_conv nil)
    (powerseq const-decl "sequence[real]" power_series nil)
    (powerseries const-decl "sequence[real]" power_series nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posint nonempty-type-eq-decl nil integers nil)
    (abs const-decl "sequence[real]" series nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (abs_mult formula-decl nil real_props nil)
    (a!1 skolem-const-decl "sequence[real]" power_series_deriv_scaf
     nil)
    (NP2NP1 skolem-const-decl "[nat -> posint]" power_series_deriv_scaf
     nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (even_plus_even_is_even application-judgement "even_int" integers
     nil)
    (powerseries_abs_conv formula-decl nil power_series_conv nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (derivseq const-decl "sequence[real]" power_series_derivseq nil)
    (derivseq_conv formula-decl nil power_series_derivseq nil)
    (nzint_abs_is_pos application-judgement "{j: posint | j >= i}"
     real_defs nil)
    (^ const-decl "real" exponentiation nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (sequence type-eq-decl nil sequences 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)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (< const-decl "bool" reals nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (/= const-decl "boolean" notequal nil)
    (T_pred const-decl "[real -> boolean]" power_series_deriv_scaf nil)
    (T formal-subtype-decl nil power_series_deriv_scaf nil)
    (x!1 skolem-const-decl "T" power_series_deriv_scaf nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nnreal_times_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil))
   nil)
  (conv_scaf0-2 nil 3352091069
   ("" (skosimp*)
    (("" (lemma "conv_series_shift")
      (("" (inst?)
        (("1" (inst - "2")
          (("1" (assert)
            (("1" (hide 2)
              (("1" (lemma "derivseq_conv")
                (("1" (inst - "a!1" "_")
                  (("1" (replace -2)
                    (("1" (lemma "derivseq_conv")
                      (("1" (inst - "derivseq(a!1)" "_")
                        (("1"
                          (case-replace
                           "conv_powerseries?(derivseq(a!1))")
                          (("1" (expand "derivseq")
                            (("1" (rewrite "apow_rew")
                              (("1"
                                (expand "apowerseq")
                                (("1"
                                  (lemma "powerseries_abs_conv")
                                  (("1"
                                    (expand "powerseries")
                                    (("1"
                                      (rewrite "apow_rew")
                                      (("1"
                                        (expand "apowerseq")
                                        (("1"
                                          (name
                                           "NP2NP1"
                                           "(LAMBDA n: (n+2)*(n+1))")
                                          (("1"
                                            (inst
                                             -
                                             "(LAMBDA n: NP2NP1(n)*a!1(2 + n))")
                                            (("1"
                                              (expand "abs" -2)
                                              (("1"
                                                (rewrite "abs_mult" -)
                                                (("1"
                                                  (split -2)
                                                  (("1"
                                                    (inst - "x!1")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (case-replace
                                                         "(LAMBDA (n: nat):
                                          IF n = 0 THEN abs(NP2NP1(0)) * abs(a!1(2))
                                          ELSE abs(NP2NP1(n) * a!1(2 + n) * x!1 ^ n)
                                          ENDIF) = (LAMBDA n:
                                          abs(a!1(2 + n)) * abs(x!1 ^ n) * abs(1 + n) *
                                           abs(2 + n))")
                                                        (("1"
                                                          (apply-extensionality
                                                           1
                                                           :hide?
                                                           t)
                                                          (("1"
                                                            (rewrite
                                                             "abs_mult")
                                                            (("1"
                                                              (rewrite
                                                               "abs_mult")
                                                              (("1"
                                                                (hide
                                                                 2)
                                                                (("1"
                                                                  (replace
                                                                   -2
                                                                   *
                                                                   rl)
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (lift-if)
                                                                      (("1"
                                                                        (ground)
                                                                        (("1"
                                                                          (replace
                                                                           -1)
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (assert)
                                                                              (("1"
                                                                                (hide-all-but
                                                                                 1)
                                                                                (("1"
                                                                                  (grind)
                                                                                  nil)))))))))
                                                                         ("2"
                                                                          (hide
                                                                           -)
                                                                          (("2"
                                                                            (grind)
                                                                            nil)))))))))))))))))))))))))
                                                   ("2"
                                                    (hide 2)
                                                    (("2"
                                                      (skosimp*)
                                                      (("2"
                                                        (hide -4)
                                                        (("2"
                                                          (inst
                                                           -3
                                                           "x!2")
                                                          (("2"
                                                            (case-replace
                                                             "(LAMBDA (k: nat):
                                  IF k = 0 THEN 2 * a!1(2)
                                  ELSE 2 * (a!1(2 + k) * x!2 ^ k) +
                                        3 * (k * a!1(2 + k) * x!2 ^ k)
                                        + k * k * a!1(2 + k) * x!2 ^ k
                                  ENDIF) = (LAMBDA (k: nat):
                                  IF k = 0 THEN NP2NP1(0) * a!1(2)
                                  ELSE NP2NP1(k) * a!1(2 + k) * x!2 ^ k
                                  ENDIF)")
                                                            (("2"
                                                              (apply-extensionality
                                                               1
                                                               :hide?
                                                               t)
                                                              (("2"
                                                                (hide
                                                                 2)
                                                                (("2"
                                                                  (lift-if)
                                                                  (("2"
                                                                    (replace
                                                                     -1
                                                                     *
                                                                     rl)
                                                                    (("2"
                                                                      (assert)
                                                                      nil)))))))))))))))))))))))))))))))))))))))))))
                           ("2" (hide 2)
                            (("2" (expand "conv_powerseries?")
                              (("2"
                                (skosimp*)
                                (("2"
                                  (hide -1)
                                  (("2"
                                    (expand "powerseries")
                                    (("2"
                                      (inst?)
                                      nil)))))))))))))))))))))))))))))
         ("2" (skosimp*) (("2" (assertnil))))))))
    nil)
   nil nil)
  (conv_scaf0-1 nil 3298998432
   ("" (skosimp*)
    (("" (lemma "conv_series_shift")
      (("" (inst?)
        (("1" (inst - "2")
          (("1" (assert)
            (("1" (hide 2)
              (("1" (lemma "derivseq_conv")
                (("1" (inst - "a!1" "_")
                  (("1" (replace -2)
                    (("1" (lemma "derivseq_conv")
                      (("1" (inst - "derivseq(a!1)" "_")
                        (("1"
                          (case-replace
                           "conv_powerseries?(derivseq(a!1))")
                          (("1" (expand "derivseq")
                            (("1" (expand "powerseq")
                              (("1"
                                (lemma "powerseries_abs_conv")
                                (("1"
                                  (expand "powerseries")
                                  (("1"
                                    (expand "powerseq")
                                    (("1"
                                      (name
                                       "NP2NP1"
                                       "(LAMBDA n: (n+2)*(n+1))")
                                      (("1"
                                        (inst
                                         -
                                         "(LAMBDA n: NP2NP1(n)*a!1(2 + n))")
                                        (("1"
                                          (expand "abs" -2)
                                          (("1"
                                            (rewrite "abs_mult" -)
                                            (("1"
                                              (split -2)
                                              (("1"
                                                (inst - "x!1")
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (case-replace
                                                     "(LAMBDA (n: nat):
                                  IF n = 0 THEN abs(NP2NP1(0)) * abs(a!1(2))
                                  ELSE abs(NP2NP1(n) * a!1(2 + n) * x!1 ^ n)
                                  ENDIF) = (LAMBDA n:
                                  abs(a!1(2 + n)) * abs(x!1 ^ n) * abs(1 + n) *
                                   abs(2 + n))")
                                                    (("1"
                                                      (apply-extensionality
                                                       1
                                                       :hide?
                                                       t)
                                                      (("1"
                                                        (rewrite
                                                         "abs_mult")
                                                        (("1"
                                                          (rewrite
                                                           "abs_mult")
                                                          (("1"
                                                            (hide 2)
                                                            (("1"
                                                              (replace
                                                               -2
                                                               *
                                                               rl)
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (lift-if)
                                                                  (("1"
                                                                    (ground)
                                                                    (("1"
                                                                      (replace
                                                                       -1)
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (hide-all-but
                                                                             1)
                                                                            (("1"
                                                                              (grind)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (hide
                                                                       -)
                                                                      (("2"
                                                                        (grind)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (hide 2)
                                                (("2"
                                                  (skosimp*)
                                                  (("2"
                                                    (hide -4)
                                                    (("2"
                                                      (inst -3 "x!2")
                                                      (("2"
                                                        (case-replace
                                                         "(LAMBDA (k: nat):
                          IF k = 0 THEN 2 * a!1(2)
                          ELSE 2 * (a!1(2 + k) * x!2 ^ k) +
                                3 * (k * a!1(2 + k) * x!2 ^ k)
                                + k * k * a!1(2 + k) * x!2 ^ k
                          ENDIF) = (LAMBDA (k: nat):
                          IF k = 0 THEN NP2NP1(0) * a!1(2)
                          ELSE NP2NP1(k) * a!1(2 + k) * x!2 ^ k
                          ENDIF)")
                                                        (("2"
                                                          (apply-extensionality
                                                           1
                                                           :hide?
                                                           t)
                                                          (("2"
                                                            (hide 2)
                                                            (("2"
                                                              (lift-if)
                                                              (("2"
                                                                (replace
                                                                 -1
                                                                 *
                                                                 rl)
                                                                (("2"
                                                                  (assert)
                                                                  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 "conv_powerseries?")
                              (("2"
                                (skosimp*)
                                (("2"
                                  (hide -1)
                                  (("2"
                                    (expand "powerseries")
                                    (("2" (inst?) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (skosimp*) (("2" (assertnil nil)) nil))
        nil))
      nil))
    nil)
   ((conv_series_shift formula-decl nil series nil)
    (powerseq const-decl "sequence[real]" power_series nil)
    (abs const-decl "sequence[real]" series nil)
    (powerseries_abs_conv formula-decl nil power_series_conv nil)
    (derivseq const-decl "sequence[real]" power_series_derivseq nil)
    (derivseq_conv formula-decl nil power_series_derivseq nil))
   shostak))
 (A2seq_TCC1 0
  (A2seq_TCC1-1 nil 3299340671
   ("" (skosimp*) (("" (assertnil nil)) nil)
   ((nonzero_abs_is_pos application-judgement "{y: posreal | y >= x}"
     real_defs nil)
    (nonneg_real_max application-judgement
     "{z: nonneg_real | z >= x AND z >= y}" real_defs nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   shostak))
 (A2_conv_scaf 0
  (A2_conv_scaf-4 nil 3352112983
   ("" (skosimp*)
    (("" (expand "powerseq")
      ((""
        (case-replace "abs(LAMBDA (k: nat): a!1(k) * x!1 ^ k) =
                          (LAMBDA (k: nat): abs(a!1(k) * x!1 ^ k))")
        (("1" (hide -1)
          (("1"
            (case-replace
             "(LAMBDA (k_1: nat): abs(a!1)(k_1) * abs(x!1) ^ k_1) =
     (LAMBDA (k_1: nat): abs(a!1(k_1)) * abs(x!1^ k_1))")
            (("1" (hide -1)
              (("1" (apply-extensionality 1 :hide? t)
                (("1" (rewrite "abs_mult"nil nil)
                 ("2" (skosimp*)
                  (("2" (assert)
                    (("2" (rewrite "abs_mult" :dir rl)
                      (("2" (assertnil nil)) nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (hide 2)
              (("2" (apply-extensionality 1 :hide? t)
                (("2" (expand "abs" 1 1)
                  (("2" (assert)
                    (("2" (lemma "abs_expt")
                      (("2" (expand "^")
                        (("2" (inst?)
                          (("2" (replace -1 :dir rl)
                            (("2" (propax) nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (hide 2)
          (("2" (expand "abs")
            (("2" (apply-extensionality 1 :hide? t)
              (("1" (lift-if)
                (("1" (ground)
                  (("1" (expand "abs") (("1" (propax) nil nil)) nil)
                   ("2" (expand "abs") (("2" (propax) nil nil)) nil))
                  nil))
                nil)
               ("2" (skosimp*) (("2" (assertnil nil)) nil)
               ("3" (skosimp*) (("3" (assertnil nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((powerseq const-decl "sequence[real]" power_series nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (< const-decl "bool" reals nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (minus_real_is_real application-judgement "real" reals nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (abs_expt formula-decl nil exponent_props "reals/")
    (nnreal_expt application-judgement "nnreal" exponentiation nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (abs_mult formula-decl nil real_props nil)
    (nnreal_times_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (a!1 skolem-const-decl "sequence[real]" power_series_deriv_scaf
     nil)
    (x!1 skolem-const-decl "T" power_series_deriv_scaf nil)
    (nnreal_exp application-judgement "nnreal" exponentiation nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (T formal-subtype-decl nil power_series_deriv_scaf nil)
    (T_pred const-decl "[real -> boolean]" power_series_deriv_scaf nil)
    (^ const-decl "real" exponentiation nil)
    (/= const-decl "boolean" notequal nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (abs const-decl "sequence[real]" series nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (sequence type-eq-decl nil sequences 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)
    (real_times_real_is_real application-judgement "real" reals nil))
   nil)
  (A2_conv_scaf-3 nil 3352112910
   ("" (skosimp*)
    (("" (rewrite "apow_rew")
      (("" (rewrite "apow_rew")
        (("" (expand "apowerseq")
          (("" (expand "abs" 1)
            (("" (apply-extensionality 1 :hide? t)
              (("1" (lift-if)
                (("1" (ground)
                  (("1"
                    (case-replace
                     "IF x!1 < 0 THEN -x!1 ELSE x!1 ENDIF = abs(x!1)")
                    (("1" (rewrite "abs_mult")
                      (("1" (rewrite "abs_hat")
                        (("1" (flatten)
                          (("1" (replace -1)
                            (("1" (assert)
                              (("1"
                                (rewrite "abs_0")
                                (("1" (assertnil)))))))))))))
                     ("2" (hide 3) (("2" (grind) nil)))))))))
               ("2" (skosimp*)
                (("2"
                  (case-replace
                   "IF x!1 < 0 THEN -x!1 ELSE x!1 ENDIF = abs(x!1)")
                  (("1" (assert)
                    (("1" (assert)
                      (("1" (assert)
                        (("1" (hide -1)
                          (("1"
                            (case-replace
                             "abs(x!1) ^ k!1 >= x!1 ^ k!1")
                            (("1"
                              (case-replace
                               "abs(a!1(k!1)) >= a!1(k!1)")
                              (("1"
                                (case "x!1 = 0")
                                (("1"
                                  (replace -1)
                                  (("1"
                                    (rewrite "abs_0")
                                    (("1" (assertnil)))))
                                 ("2"
                                  (name "AA" "abs(x!1) ^ k!1")
                                  (("2"
                                    (case "AA > 0")
                                    (("1"
                                      (replace -2)
                                      (("1"
                                        (hide -2)
                                        (("1"
                                          (name "CC" "abs(a!1(k!1))")
                                          (("1"
                                            (case "CC >= 0")
                                            (("1"
                                              (replace -2)
                                              (("1"
                                                (hide -2)
                                                (("1"
                                                  (mult-ineq -3 -4)
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (postpone)
                                                      nil)))
                                                   ("2"
                                                    (reveal -1 -2)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (replace
                                                         -2
                                                         *
                                                         RL)
                                                        (("2"
                                                          (ground)
                                                          (("1"
                                                            (replace
                                                             -4
                                                             +
                                                             :dir
                                                             rl)
                                                            (("1"
                                                              (hide-all-but
                                                               (1
                                                                -2
                                                                3
                                                                4))
                                                              (("1"
                                                                (lemma
                                                                 "abs_expt")
                                                                (("1"
                                                                  (expand
                                                                   "^")
                                                                  (("1"
                                                                    (inst
                                                                     -
                                                                     "k!1"
                                                                     "x!1")
                                                                    (("1"
                                                                      (replace
                                                                       -1)
                                                                      (("1"
                                                                        (hide
                                                                         -1)
                                                                        (("1"
                                                                          (grind
                                                                           :exclude
                                                                           "expt")
                                                                          nil)))))))))))))))
                                                           ("2"
                                                            (replace
                                                             -2
                                                             +
                                                             :dir
                                                             rl)
                                                            (("2"
                                                              (hide-all-but
                                                               (1 3 4))
                                                              (("2"
                                                                (lemma
                                                                 "abs_expt")
                                                                (("2"
                                                                  (expand
                                                                   "^")
                                                                  (("2"
                                                                    (inst
                                                                     -
                                                                     "k!1"
                                                                     "x!1")
                                                                    (("2"
                                                                      (replace
                                                                       -1)
                                                                      (("2"
                                                                        (hide
                                                                         -1
                                                                         3)
                                                                        (("2"
                                                                          (grind
                                                                           :exclude
                                                                           "expt")
                                                                          nil)))))))))))))))))))))))))))))
                                             ("2" (assertnil)))))))))
                                     ("2"
                                      (assert)
                                      (("2"
                                        (replace -1 + :dir rl)
                                        (("2"
                                          (hide-all-but (1 2 3))
                                          (("2"
                                            (lemma "abs_expt")
                                            (("2"
                                              (expand "^")
                                              (("2"
                                                (inst - "k!1" "x!1")
                                                (("2"
                                                  (assert)
                                                  (("2"
                                                    (replace
                                                     -1
                                                     :dir
                                                     rl)
                                                    (("2"
                                                      (hide -1)
                                                      (("2"
                                                        (lemma
                                                         "expt_eq_0")
                                                        (("2"
                                                          (expand "^")
                                                          (("2"
                                                            (inst?)
                                                            (("2"
                                                              (assert)
                                                              nil)))))))))))))))))))))))))))))))
                               ("2" (hide 3) (("2" (assertnil)))))
                             ("2" (hide 3)
                              (("2"
                                (assert)
                                (("2"
                                  (rewrite "abs_hat" :dir rl)
                                  (("1" (assertnil)
                                   ("2"
                                    (flatten)
                                    (("2"
                                      (replace -1)
                                      (("2"
                                        (rewrite "abs_0")
                                        (("2"
                                          (assert)
                                          nil)))))))))))))))))))))))
                   ("2" (hide 3) (("2" (grind) nil)))))))
               ("3" (skosimp*) (("3" (assert) (("3" (assertnil)))))
               ("4" (skosimp*)
                (("4" (lift-if) (("4" (ground) nil))))))))))))))))
    nil)
   nil nil)
  (A2_conv_scaf-2 nil 3352094498
   ("" (skosimp*)
    (("" (rewrite "apow_rew")
      (("" (rewrite "apow_rew")
        (("" (expand "apowerseq")
          (("" (expand "abs" 1)
            (("" (apply-extensionality 1 :hide? t)
              (("1" (lift-if)
                (("1" (ground)
                  (("1"
                    (case-replace
                     "IF x!1 < 0 THEN -x!1 ELSE x!1 ENDIF = abs(x!1)")
                    (("1" (rewrite "abs_mult")
                      (("1" (rewrite "abs_hat")
                        (("1" (flatten)
                          (("1" (replace -1)
                            (("1" (assert)
                              (("1"
                                (rewrite "abs_0")
                                (("1" (assertnil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide 3) (("2" (grind) nil nil)) nil))
                    nil))
                  nil))
                nil)
               ("2" (skosimp*)
                (("2"
                  (case-replace
                   "IF x!1 < 0 THEN -x!1 ELSE x!1 ENDIF = abs(x!1)")
                  (("1" (assert)
                    (("1" (assert)
                      (("1" (assert)
                        (("1" (hide -1)
                          (("1"
                            (case-replace
                             "abs(x!1) ^ k!1 >= x!1 ^ k!1")
                            (("1"
                              (case-replace
                               "abs(a!1(k!1)) >= a!1(k!1)")
                              (("1"
                                (case "x!1 = 0")
                                (("1"
                                  (replace -1)
                                  (("1"
                                    (rewrite "abs_0")
                                    (("1" (assertnil nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (name "AA" "abs(x!1) ^ k!1")
                                  (("2"
                                    (case "AA > 0")
                                    (("1"
                                      (replace -2)
                                      (("1"
                                        (hide -2)
                                        (("1"
                                          (name "CC" "abs(a!1(k!1))")
                                          (("1"
                                            (case "CC >= 0")
                                            (("1"
                                              (replace -2)
                                              (("1"
                                                (hide -2)
                                                (("1"
                                                  (mult-ineq -3 -4)
                                                  (("1"
                                                    (flatten)
                                                    (("1"
                                                      (reveal -1 -2)
                                                      (("1"
                                                        (split +)
                                                        (("1"
                                                          (replace
                                                           -1
                                                           *
                                                           rl)
                                                          (("1"
                                                            (hide-all-but
                                                             1)
                                                            (("1"
                                                              (grind)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (replace
                                                           -2
                                                           *
                                                           rl)
                                                          (("2"
                                                            (hide-all-but
                                                             1)
                                                            (("2"
                                                              (rewrite
                                                               "abs_hat")
                                                              (("1"
                                                                (rewrite
                                                                 "abs_hat")
                                                                (("1"
                                                                  (rewrite
                                                                   "abs_abs")
                                                                  (("1"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (reveal
                                                                 1)
                                                                (("2"
                                                                  (lemma
                                                                   "abs_eq_0")
                                                                  (("2"
                                                                    (inst?)
                                                                    (("2"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (assert)
                                      (("2"
                                        (rewrite "abs_hat" :dir rl)
                                        (("2"
                                          (assert)
                                          (("2"
                                            (replace -1 * rl)
                                            (("2"
                                              (hide - 4)
                                              (("2"
                                                (lemma "expt_pos")
                                                (("2"
                                                  (inst?)
                                                  (("1"
                                                    (lemma "abs_eq_0")
                                                    (("1"
                                                      (inst?)
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (lemma "abs_eq_0")
                                                    (("2"
                                                      (inst?)
                                                      (("2"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide 3)
                                (("2" (grind) nil nil))
                                nil))
                              nil)
                             ("2" (hide 3)
                              (("2"
                                (rewrite "abs_hat" :dir rl)
                                (("1" (assertnil nil)
                                 ("2"
                                  (flatten)
                                  (("2"
                                    (replace -1)
                                    (("2"
                                      (rewrite "abs_0")
                                      (("2" (assertnil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (hide 3) (("2" (grind) nil nil)) nil))
                  nil))
                nil)
               ("3" (skosimp*) (("3" (assertnil nil)) nil)
               ("4" (skosimp*) (("4" (assertnil nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((abs const-decl "sequence[real]" series nil)
    (abs_hat formula-decl nil exponent_props "reals/")
    (hat_02n formula-decl nil power_series nil)
    (apowerseq const-decl "sequence[real]" power_series nil)
    (apow_rew formula-decl nil power_series nil))
   nil)
  (A2_conv_scaf-1 nil 3299581520
   ("" (skosimp*)
    (("" (expand "powerseq")
      (("" (expand "abs" 1)
        (("" (apply-extensionality 1 :hide? t)
          (("1" (lift-if)
            (("1" (ground)
              (("1"
                (case-replace
                 "IF x!1 < 0 THEN -x!1 ELSE x!1 ENDIF = abs(x!1)")
                (("1" (rewrite "abs_mult")
                  (("1" (rewrite "abs_hat")
                    (("1" (flatten)
                      (("1" (replace -1)
                        (("1" (assert)
                          (("1" (rewrite "zero_hat")
                            (("1" (rewrite "abs_0")
                              (("1"
                                (assert)
                                (("1"
                                  (rewrite "zero_hat")
                                  (("1" (assertnil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (hide 3)
                  (("2" (ground) (("2" (grind) nil nil)) nil)) nil))
                nil))
              nil))
            nil)
           ("2" (skosimp*)
            (("2"
              (case-replace
               "IF x!1 < 0 THEN -x!1 ELSE x!1 ENDIF = abs(x!1)")
              (("1" (assert)
                (("1" (assert)
                  (("1" (assert)
                    (("1" (hide -1)
                      (("1"
                        (case-replace "abs(x!1) ^ k!1 >= x!1 ^ k!1")
                        (("1"
                          (case-replace "abs(a!1(k!1)) >= a!1(k!1)")
                          (("1" (case "x!1 = 0")
                            (("1" (replace -1)
                              (("1"
                                (rewrite "abs_0")
                                (("1"
                                  (assert)
                                  (("1"
                                    (rewrite "zero_hat")
                                    (("1" (assertnil nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (name "AA" "abs(x!1) ^ k!1")
                              (("2"
                                (case "AA > 0")
                                (("1"
                                  (replace -2)
                                  (("1"
                                    (hide -2)
                                    (("1"
                                      (name "CC" "abs(a!1(k!1))")
                                      (("1"
                                        (case "CC >= 0")
                                        (("1"
                                          (replace -2)
                                          (("1"
                                            (hide -2)
                                            (("1"
                                              (mult-ineq -3 -4)
                                              (("1"
                                                (flatten)
                                                (("1"
                                                  (reveal -1 -2)
                                                  (("1"
                                                    (split +)
                                                    (("1"
                                                      (replace -1 * rl)
                                                      (("1"
                                                        (hide-all-but
                                                         1)
                                                        (("1"
                                                          (grind)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (replace -2 * rl)
                                                      (("2"
                                                        (hide-all-but
                                                         1)
                                                        (("2"
                                                          (rewrite
                                                           "abs_hat")
                                                          (("1"
                                                            (rewrite
                                                             "abs_hat")
                                                            (("1"
                                                              (rewrite
                                                               "abs_abs")
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (reveal 1)
                                                            (("2"
                                                              (lemma
                                                               "abs_eq_0")
                                                              (("2"
                                                                (inst?)
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2" (assertnil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (assert)
                                  (("2"
                                    (rewrite "abs_hat" :dir rl)
                                    (("2"
                                      (assert)
                                      (("2"
                                        (replace -1 * rl)
                                        (("2"
                                          (hide - 4)
                                          (("2"
                                            (lemma "expt_pos")
                                            (("2"
                                              (inst?)
                                              (("1"
                                                (lemma "abs_eq_0")
                                                (("1"
                                                  (inst?)
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (lemma "abs_eq_0")
                                                (("2"
                                                  (inst?)
                                                  (("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (hide 3) (("2" (grind) nil nil)) nil))
                          nil)
                         ("2" (hide 3)
                          (("2" (rewrite "abs_hat" :dir rl)
                            (("1" (assertnil nil)
                             ("2" (flatten)
                              (("2"
                                (replace -1)
                                (("2"
                                  (rewrite "abs_0")
                                  (("2" (assertnil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (hide 3) (("2" (grind) nil nil)) nil))
              nil))
            nil)
           ("3" (skosimp*) (("3" (assertnil nil)) nil)
           ("4" (skosimp*) (("4" (assertnil nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((abs const-decl "sequence[real]" series nil)
    (abs_hat formula-decl nil exponent_props "reals/")
    (zero_hat formula-decl nil exponent_props "reals/")
    (powerseq const-decl "sequence[real]" power_series nil))
   nil))
 (A2_conv 0
  (A2_conv-6 "asdf" 3352094804
   ("" (skosimp*)
    (("" (name "ALPH" "max(abs(x!1), abs(xp!1))")
      (("" (case "ALPH /= 0")
        (("1" (case "T_pred(ALPH)")
          (("1" (flatten)
            (("1" (expand "A2seq")
              (("1" (replace -2)
                (("1" (hide -2)
                  (("1" (lemma "conv_derivseq")
                    (("1" (inst - "derivseq(a!1)")
                      (("1" (split -1)
                        (("1" (lemma "conv_series_shift")
                          (("1"
                            (inst - "2" "(LAMBDA (k):
                                                                            IF k < 2 THEN k
                                                                            ELSE abs(k) * abs(k - 1) *
                                                                                  abs(a!1(k) * ALPH ^ (k - 2))
                                                                            ENDIF)")
                            (("1" (assert)
                              (("1"
                                (lemma "end_series_conv")
                                (("1"
                                  (inst?)
                                  (("1"
                                    (assert)
                                    (("1"
                                      (hide 1 5)
                                      (("1"
                                        (lemma "end_series_conv")
                                        (("1"
                                          (inst?)
                                          (("1"
                                            (assert)
                                            (("1"
                                              (hide 1 5)
                                              (("1"
                                                (inst -1 "3")
                                                (("1"
                                                  (lemma
                                                   "powerseries_abs_conv")
                                                  (("1"
                                                    (inst
                                                     -
                                                     "fseq(a!1)")
                                                    (("1"
                                                      (split -1)
                                                      (("1"
                                                        (inst - "ALPH")
                                                        (("1"
                                                          (case-replace
                                                           "abs(powerseq(fseq(a!1),ALPH)) = powerseq((LAMBDA n:
                                     abs(1 + n) * abs(2 + n) * abs(a!1(2 + n))),
                                     abs(ALPH))")
                                                          (("1"
                                                            (hide -1)
                                                            (("1"
                                                              (case-replace
                                                               "abs(ALPH) = ALPH")
                                                              (("1"
                                                                (rewrite
                                                                 "apow_rew")
                                                                (("1"
                                                                  (expand
                                                                   "apowerseq")
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (case-replace
                                                                       "(LAMBDA (k: nat):
                                                                                                                                                          IF k = 0 THEN abs(1) * abs(2) * abs(a!1(2))
                                                                                                                                                          ELSE abs(a!1(2 + k)) * abs(1 + k) * abs(2 + k) *
                                                                                                                                                                ALPH ^ k
                                                                                                                                                          ENDIF)
                                                                                                                                                   = (LAMBDA n:
                                                                                                                                                          abs(1 + n) * abs(2 + n) *
                                                                                                                                                           abs(a!1(2 + n) * ALPH ^ n))")
                                                                      (("1"
                                                                        (hide
                                                                         -1)
                                                                        (("1"
                                                                          (lemma
                                                                           "end_series_conv")
                                                                          (("1"
                                                                            (inst?)
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (hide
                                                                         2)
                                                                        (("2"
                                                                          (apply-extensionality
                                                                           1
                                                                           :hide?
                                                                           t)
                                                                          (("2"
                                                                            (lift-if)
                                                                            (("2"
                                                                              (ground)
                                                                              (("1"
                                                                                (replace
                                                                                 -1)
                                                                                (("1"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (hide
                                                                                 -2
                                                                                 -3
                                                                                 -4)
                                                                                (("2"
                                                                                  (rewrite
                                                                                   "abs_mult")
                                                                                  (("2"
                                                                                    (assert)
                                                                                    (("2"
                                                                                      (rewrite
                                                                                       "abs_hat")
                                                                                      (("2"
                                                                                        (case-replace
                                                                                         "abs(ALPH) = ALPH")
                                                                                        (("2"
                                                                                          (assert)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (reveal
                                                                 -8)
                                                                (("2"
                                                                  (hide
                                                                   -2
                                                                   -3
                                                                   -4
                                                                   -5
                                                                   2
                                                                   4)
                                                                  (("2"
                                                                    (replace
                                                                     -1
                                                                     *
                                                                     rl)
                                                                    (("2"
                                                                      (grind)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (hide
                                                             -1
                                                             -2
                                                             -3
                                                             2)
                                                            (("2"
                                                              (expand
                                                               "fseq")
                                                              (("2"
                                                                (rewrite
                                                                 "A2_conv_scaf")
                                                                (("2"
                                                                  (case-replace
                                                                   "abs((LAMBDA n: (1 + n) * (2 + n) * a!1(2 + n))) = (LAMBDA n: abs(1 + n) * abs(2 + n) * abs(a!1(2 + n)))")
                                                                  (("1"
                                                                    (hide
                                                                     2)
                                                                    (("1"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (hide
                                                                     2)
                                                                    (("2"
                                                                      (case-replace
                                                                       "abs((LAMBDA n: (1 + n) * (2 + n) * a!1(2 + n))) = abs(fseq(a!1))")
                                                                      (("1"
                                                                        (hide
                                                                         -1)
                                                                        (("1"
                                                                          (apply-extensionality
                                                                           1
                                                                           :hide?
                                                                           t)
                                                                          (("1"
                                                                            (expand
                                                                             "abs"
                                                                             1
                                                                             1)
                                                                            (("1"
                                                                              (assert)
                                                                              (("1"
                                                                                (expand
                                                                                 "fseq")
                                                                                (("1"
                                                                                  (case-replace
                                                                                   "(2 * a!1(2 + x!2) + 3 * (a!1(2 + x!2) * x!2) +
                                               a!1(2 + x!2) * x!2 * x!2) = a!1(2 + x!2) * (1 + x!2) * (2 + x!2)")
                                                                                  (("1"
                                                                                    (rewrite
                                                                                     "abs_mult")
                                                                                    (("1"
                                                                                      (hide
                                                                                       -1)
                                                                                      (("1"
                                                                                        (case-replace
                                                                                         "a!1(2 + x!2) + a!1(2 + x!2) * x!2 = (1+x!2)*a!1(2 + x!2)")
                                                                                        (("1"
                                                                                          (rewrite
                                                                                           "abs_mult")
                                                                                          (("1"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (assert)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil)
                                                                                   ("2"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (hide
                                                                         2)
                                                                        (("2"
                                                                          (expand
                                                                           "fseq")
                                                                          (("2"
                                                                            (propax)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (skosimp*)
                                                        (("2"
                                                          (hide 2)
                                                          (("2"
                                                            (expand
                                                             "conv_powerseries?")
                                                            (("2"
                                                              (inst?)
                                                              (("2"
                                                                (expand
                                                                 "derivseq")
                                                                (("2"
                                                                  (expand
                                                                   "fseq")
                                                                  (("2"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (skosimp*) nil nil))
                            nil))
                          nil)
                         ("2" (assert)
                          (("2" (hide 4)
                            (("2" (lemma "conv_derivseq")
                              (("2"
                                (inst - "a!1")
                                (("2" (assertnil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (lemma "ball")
            (("2" (inst - "x!1")
              (("2" (lemma "ball")
                (("2" (inst - "xp!1")
                  (("2" (hide -5 3) (("2" (grind) nil nil)) nil)) nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (flatten)
          (("2" (assert)
            (("2" (hide -3 2) (("2" (grind) nil nil)) nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((T formal-subtype-decl nil power_series_deriv_scaf nil)
    (T_pred const-decl "[real -> boolean]" power_series_deriv_scaf nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (>= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans 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)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (nonneg_real_max application-judgement
     "{z: nonneg_real | z >= x AND z >= y}" real_defs nil)
    (nnreal_exp application-judgement "nnreal" exponentiation nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (A2seq const-decl "real" power_series_deriv_scaf nil)
    (derivseq const-decl "sequence[real]" power_series_derivseq nil)
    (sequence type-eq-decl nil sequences 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)
    (conv_series_shift formula-decl nil series nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (nzint_abs_is_pos application-judgement "{j: posint | j >= i}"
     real_defs nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (powerseries_abs_conv formula-decl nil power_series_conv nil)
    (powerseq const-decl "sequence[real]" power_series nil)
    (abs const-decl "sequence[real]" series nil)
    (apowerseq const-decl "sequence[real]" power_series nil)
    (nnreal type-eq-decl nil real_types nil)
    (nzrat_abs_is_pos application-judgement "{r: posrat | r >= q}"
     real_defs nil)
    (expt_x0 formula-decl nil exponentiation nil)
    (even_plus_even_is_even application-judgement "even_int" integers
     nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (abs_mult formula-decl nil real_props nil)
    (nzreal nonempty-type-eq-decl nil reals nil)
    (abs_hat formula-decl nil exponent_props "reals/")
    (apow_rew formula-decl nil power_series nil)
    (minus_real_is_real application-judgement "real" reals nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (A2_conv_scaf formula-decl nil power_series_deriv_scaf nil)
    (conv_powerseries? const-decl "bool" power_series_conv nil)
    (fseq const-decl "real" power_series_deriv_scaf nil)
    (end_series_conv formula-decl nil series nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (^ const-decl "real" exponentiation nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (ALPH skolem-const-decl
     "{z: nonneg_real | z >= abs(x!1) AND z >= abs(xp!1)}"
     power_series_deriv_scaf nil)
    (xp!1 skolem-const-decl "T" power_series_deriv_scaf nil)
    (x!1 skolem-const-decl "T" power_series_deriv_scaf nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (< const-decl "bool" reals nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nnreal_times_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (conv_derivseq formula-decl nil power_series_derivseq nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (int_abs_is_nonneg application-judgement "{j: nonneg_int | j >= i}"
     real_defs nil)
    (ball formula-decl nil power_series_deriv_scaf nil)
    (/= const-decl "boolean" notequal nil))
   nil)
  (A2_conv-5 "asdf" 3299581548
   ("" (skosimp*)
    (("" (name "ALPH" "max(abs(x!1), abs(xp!1))")
      (("" (case "ALPH /= 0")
        (("1" (case "T_pred(ALPH)")
          (("1" (flatten)
            (("1" (expand "A2seq")
              (("1" (replace -2)
                (("1" (hide -2)
                  (("1" (lemma "conv_derivseq")
                    (("1" (inst - "derivseq(a!1)")
                      (("1" (split -1)
                        (("1" (lemma "conv_series_shift")
                          (("1"
                            (inst - "2" "(LAMBDA (k):
                                                                    IF k < 2 THEN k
                                                                    ELSE abs(k) * abs(k - 1) *
                                                                          abs(a!1(k) * ALPH ^ (k - 2))
                                                                    ENDIF)")
                            (("1" (assert)
                              (("1"
                                (lemma "end_series_conv")
                                (("1"
                                  (inst?)
                                  (("1"
                                    (assert)
                                    (("1"
                                      (hide 1 5)
                                      (("1"
                                        (lemma "end_series_conv")
                                        (("1"
                                          (inst?)
                                          (("1"
                                            (assert)
                                            (("1"
                                              (hide 1 5)
                                              (("1"
                                                (inst -1 "3")
                                                (("1"
                                                  (lemma
                                                   "powerseries_abs_conv")
                                                  (("1"
                                                    (inst
                                                     -
                                                     "fseq(a!1)")
                                                    (("1"
                                                      (split -1)
                                                      (("1"
                                                        (inst - "ALPH")
                                                        (("1"
                                                          (case-replace
                                                           "abs(powerseq(fseq(a!1),ALPH)) = powerseq((LAMBDA n:
                         abs(1 + n) * abs(2 + n) * abs(a!1(2 + n))),
                         abs(ALPH))")
                                                          (("1"
                                                            (hide -1)
                                                            (("1"
                                                              (case-replace
                                                               "abs(ALPH) = ALPH")
                                                              (("1"
                                                                (expand
                                                                 "powerseq")
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (case-replace
                                                                     "(LAMBDA (k: nat):
                                                                                                                                          IF k = 0 THEN abs(1) * abs(2) * abs(a!1(2))
                                                                                                                                          ELSE abs(a!1(2 + k)) * abs(1 + k) * abs(2 + k) *
                                                                                                                                                ALPH ^ k
                                                                                                                                          ENDIF)
                                                                                                                                   = (LAMBDA n:
                                                                                                                                          abs(1 + n) * abs(2 + n) *
                                                                                                                                           abs(a!1(2 + n) * ALPH ^ n))")
                                                                    (("1"
                                                                      (hide
                                                                       -1)
                                                                      (("1"
                                                                        (lemma
                                                                         "end_series_conv")
                                                                        (("1"
                                                                          (inst?)
                                                                          (("1"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (hide
                                                                       2)
                                                                      (("2"
                                                                        (apply-extensionality
                                                                         1
                                                                         :hide?
                                                                         t)
                                                                        (("2"
                                                                          (lift-if)
                                                                          (("2"
                                                                            (ground)
                                                                            (("1"
                                                                              (replace
                                                                               -1)
                                                                              (("1"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (hide
                                                                               -2
                                                                               -3
                                                                               -4)
                                                                              (("2"
                                                                                (rewrite
                                                                                 "abs_mult")
                                                                                (("2"
                                                                                  (assert)
                                                                                  (("2"
                                                                                    (rewrite
                                                                                     "abs_hat")
                                                                                    (("2"
                                                                                      (case-replace
                                                                                       "abs(ALPH) = ALPH")
                                                                                      (("2"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (reveal
                                                                 -8)
                                                                (("2"
                                                                  (hide
                                                                   -2
                                                                   -3
                                                                   -4
                                                                   -5
                                                                   2
                                                                   4)
                                                                  (("2"
                                                                    (replace
                                                                     -1
                                                                     *
                                                                     rl)
                                                                    (("2"
                                                                      (grind)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (hide
                                                             -1
                                                             -2
                                                             -3
                                                             2)
                                                            (("2"
                                                              (expand
                                                               "fseq")
                                                              (("2"
                                                                (rewrite
                                                                 "A2_conv_scaf")
                                                                (("2"
                                                                  (case-replace
                                                                   "abs((LAMBDA n: (1 + n) * (2 + n) * a!1(2 + n))) = (LAMBDA n: abs(1 + n) * abs(2 + n) * abs(a!1(2 + n)))")
                                                                  (("1"
                                                                    (hide
                                                                     2)
                                                                    (("1"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (hide
                                                                     2)
                                                                    (("2"
                                                                      (case-replace
                                                                       "abs((LAMBDA n: (1 + n) * (2 + n) * a!1(2 + n))) = abs(fseq(a!1))")
                                                                      (("1"
                                                                        (hide
                                                                         -1)
                                                                        (("1"
                                                                          (apply-extensionality
                                                                           1
                                                                           :hide?
                                                                           t)
                                                                          (("1"
                                                                            (expand
                                                                             "abs"
                                                                             1
                                                                             1)
                                                                            (("1"
                                                                              (assert)
                                                                              (("1"
                                                                                (expand
                                                                                 "fseq")
                                                                                (("1"
                                                                                  (case-replace
                                                                                   "(2 * a!1(2 + x!2) + 3 * (a!1(2 + x!2) * x!2) +
                             a!1(2 + x!2) * x!2 * x!2) = a!1(2 + x!2) * (1 + x!2) * (2 + x!2)")
                                                                                  (("1"
                                                                                    (rewrite
                                                                                     "abs_mult")
                                                                                    (("1"
                                                                                      (hide
                                                                                       -1)
                                                                                      (("1"
                                                                                        (case-replace
                                                                                         "a!1(2 + x!2) + a!1(2 + x!2) * x!2 = (1+x!2)*a!1(2 + x!2)")
                                                                                        (("1"
                                                                                          (rewrite
                                                                                           "abs_mult")
                                                                                          (("1"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (assert)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil)
                                                                                   ("2"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (hide
                                                                         2)
                                                                        (("2"
                                                                          (expand
                                                                           "fseq")
                                                                          (("2"
                                                                            (propax)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("3"
                                                                        (skosimp*)
                                                                        (("3"
                                                                          (assert)
                                                                          (("3"
                                                                            (assert)
                                                                            (("3"
                                                                              (hide
                                                                               2)
                                                                              (("3"
                                                                                (expand
                                                                                 "abs")
                                                                                (("3"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("4"
                                                                        (skosimp*)
                                                                        (("4"
                                                                          (hide
                                                                           2)
                                                                          (("4"
                                                                            (assert)
                                                                            (("4"
                                                                              (expand
                                                                               "abs")
                                                                              (("4"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (skosimp*)
                                                        (("2"
                                                          (hide 2)
                                                          (("2"
                                                            (expand
                                                             "conv_powerseries?")
                                                            (("2"
                                                              (inst?)
                                                              (("2"
                                                                (expand
                                                                 "derivseq")
                                                                (("2"
                                                                  (expand
                                                                   "fseq")
                                                                  (("2"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (skosimp*) nil nil))
                            nil))
                          nil)
                         ("2" (assert)
                          (("2" (hide 4)
                            (("2" (lemma "conv_derivseq")
                              (("2"
                                (inst - "a!1")
                                (("2" (assertnil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (lemma "ball")
            (("2" (inst - "x!1")
              (("2" (lemma "ball")
                (("2" (inst - "xp!1")
                  (("2" (hide -5 3) (("2" (grind) nil nil)) nil)) nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (flatten)
          (("2" (assert)
            (("2" (hide -3 2) (("2" (grind) nil nil)) nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((derivseq const-decl "sequence[real]" power_series_derivseq nil)
    (conv_series_shift formula-decl nil series nil)
    (powerseries_abs_conv formula-decl nil power_series_conv nil)
    (powerseq const-decl "sequence[real]" power_series nil)
    (abs const-decl "sequence[real]" series nil)
    (abs_hat formula-decl nil exponent_props "reals/")
    (end_series_conv formula-decl nil series nil)
    (conv_derivseq formula-decl nil power_series_derivseq nil))
   nil)
  (A2_conv-4 "asdf" 3299574319
   ("" (skosimp*)
    (("" (name "ALPH" "max(abs(x!1), abs(xp!1))")
      (("" (case "ALPH /= 0")
        (("1" (case "T_pred(ALPH)")
          (("1" (flatten)
            (("1" (expand "A2seq")
              (("1" (replace -2)
                (("1" (hide -2)
                  (("1" (lemma "conv_derivseq")
                    (("1" (inst - "derivseq(a!1)")
                      (("1" (split -1)
                        (("1" (lemma "conv_series_shift")
                          (("1"
                            (inst - "2" "(LAMBDA (k):
                                                            IF k < 2 THEN k
                                                            ELSE abs(k) * abs(k - 1) *
                                                                  abs(a!1(k) * ALPH ^ (k - 2))
                                                            ENDIF)")
                            (("1" (assert)
                              (("1"
                                (lemma "end_series_conv")
                                (("1"
                                  (inst?)
                                  (("1"
                                    (assert)
                                    (("1"
                                      (hide 1 5)
                                      (("1"
                                        (lemma "end_series_conv")
                                        (("1"
                                          (inst?)
                                          (("1"
                                            (assert)
                                            (("1"
                                              (hide 1 5)
                                              (("1"
                                                (inst -1 "3")
                                                (("1"
                                                  (lemma
                                                   "powerseries_abs_conv")
                                                  (("1"
                                                    (inst
                                                     -
                                                     "fseq(a!1)")
                                                    (("1"
                                                      (split -1)
                                                      (("1"
                                                        (inst - "ALPH")
                                                        (("1"
                                                          (case-replace
                                                           "abs(powerseq(fseq(a!1),ALPH)) = powerseq((LAMBDA n:
             abs(1 + n) * abs(2 + n) * abs(a!1(2 + n))),
             abs(ALPH))")
                                                          (("1"
                                                            (hide -1)
                                                            (("1"
                                                              (case-replace
                                                               "abs(ALPH) = ALPH")
                                                              (("1"
                                                                (expand
                                                                 "powerseq")
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (case-replace
                                                                     "(LAMBDA (k: nat):
                                                                                                                          IF k = 0 THEN abs(1) * abs(2) * abs(a!1(2))
                                                                                                                          ELSE abs(a!1(2 + k)) * abs(1 + k) * abs(2 + k) *
                                                                                                                                ALPH ^ k
                                                                                                                          ENDIF)
                                                                                                                   = (LAMBDA n:
                                                                                                                          abs(1 + n) * abs(2 + n) *
                                                                                                                           abs(a!1(2 + n) * ALPH ^ n))")
                                                                    (("1"
                                                                      (hide
                                                                       -1)
                                                                      (("1"
                                                                        (lemma
                                                                         "end_series_conv")
                                                                        (("1"
                                                                          (inst?)
                                                                          (("1"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (hide
                                                                       2)
                                                                      (("2"
                                                                        (apply-extensionality
                                                                         1
                                                                         :hide?
                                                                         t)
                                                                        (("2"
                                                                          (lift-if)
                                                                          (("2"
                                                                            (ground)
                                                                            (("1"
                                                                              (replace
                                                                               -1)
                                                                              (("1"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (hide
                                                                               -2
                                                                               -3
                                                                               -4)
                                                                              (("2"
                                                                                (rewrite
                                                                                 "abs_mult")
                                                                                (("2"
                                                                                  (assert)
                                                                                  (("2"
                                                                                    (rewrite
                                                                                     "abs_hat")
                                                                                    (("2"
                                                                                      (case-replace
                                                                                       "abs(ALPH) = ALPH")
                                                                                      (("2"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (reveal
                                                                 -8)
                                                                (("2"
                                                                  (hide
                                                                   -2
                                                                   -3
                                                                   -4
                                                                   -5
                                                                   2
                                                                   4)
                                                                  (("2"
                                                                    (replace
                                                                     -1
                                                                     *
                                                                     rl)
                                                                    (("2"
                                                                      (grind)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (hide
                                                             -1
                                                             -2
                                                             -3
                                                             2)
                                                            (("2"
                                                              (expand
                                                               "fseq")
                                                              (("2"
                                                                (rewrite
                                                                 "ABC_LEM")
                                                                (("2"
                                                                  (case-replace
                                                                   "abs((LAMBDA n: (1 + n) * (2 + n) * a!1(2 + n))) = (LAMBDA n: abs(1 + n) * abs(2 + n) * abs(a!1(2 + n)))")
                                                                  (("1"
                                                                    (hide
                                                                     2)
                                                                    (("1"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (hide
                                                                     2)
                                                                    (("2"
                                                                      (case-replace
                                                                       "abs((LAMBDA n: (1 + n) * (2 + n) * a!1(2 + n))) = abs(fseq(a!1))")
                                                                      (("1"
                                                                        (hide
                                                                         -1)
                                                                        (("1"
                                                                          (apply-extensionality
                                                                           1
                                                                           :hide?
                                                                           t)
                                                                          (("1"
                                                                            (expand
                                                                             "abs"
                                                                             1
                                                                             1)
                                                                            (("1"
                                                                              (assert)
                                                                              (("1"
                                                                                (expand
                                                                                 "fseq")
                                                                                (("1"
                                                                                  (case-replace
                                                                                   "(2 * a!1(2 + x!2) + 3 * (a!1(2 + x!2) * x!2) +
           a!1(2 + x!2) * x!2 * x!2) = a!1(2 + x!2) * (1 + x!2) * (2 + x!2)")
                                                                                  (("1"
                                                                                    (rewrite
                                                                                     "abs_mult")
                                                                                    (("1"
                                                                                      (hide
                                                                                       -1)
                                                                                      (("1"
                                                                                        (case-replace
                                                                                         "a!1(2 + x!2) + a!1(2 + x!2) * x!2 = (1+x!2)*a!1(2 + x!2)")
                                                                                        (("1"
                                                                                          (rewrite
                                                                                           "abs_mult")
                                                                                          (("1"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (assert)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil)
                                                                                   ("2"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (hide
                                                                         2)
                                                                        (("2"
                                                                          (expand
                                                                           "fseq")
                                                                          (("2"
                                                                            (propax)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("3"
                                                                        (skosimp*)
                                                                        (("3"
                                                                          (assert)
                                                                          (("3"
                                                                            (assert)
                                                                            (("3"
                                                                              (hide
                                                                               2)
                                                                              (("3"
                                                                                (expand
                                                                                 "abs")
                                                                                (("3"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("4"
                                                                        (skosimp*)
                                                                        (("4"
                                                                          (hide
                                                                           2)
                                                                          (("4"
                                                                            (assert)
                                                                            (("4"
                                                                              (expand
                                                                               "abs")
                                                                              (("4"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (skosimp*)
                                                        (("2"
                                                          (hide 2)
                                                          (("2"
                                                            (expand
                                                             "conv_powerseries?")
                                                            (("2"
                                                              (inst?)
                                                              (("2"
                                                                (expand
                                                                 "derivseq")
                                                                (("2"
                                                                  (expand
                                                                   "fseq")
                                                                  (("2"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (skosimp*) nil nil))
                            nil))
                          nil)
                         ("2" (assert)
                          (("2" (hide 4)
                            (("2" (lemma "conv_derivseq")
                              (("2"
                                (inst - "a!1")
                                (("2" (assertnil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (lemma "ball")
            (("2" (inst - "x!1")
              (("2" (lemma "ball")
                (("2" (inst - "xp!1")
                  (("2" (hide -5 3) (("2" (grind) nil nil)) nil)) nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (flatten)
          (("2" (assert)
            (("2" (hide -3 2) (("2" (grind) nil nil)) nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((conv_series_shift formula-decl nil series nil)
    (powerseries_abs_conv formula-decl nil power_series_conv nil)
    (powerseq const-decl "sequence[real]" power_series nil)
    (abs const-decl "sequence[real]" series nil)
    (abs_hat formula-decl nil exponent_props "reals/")
    (end_series_conv formula-decl nil series nil))
   nil)
  (A2_conv-3 "asdf" 3299574158
   ("" (skosimp*)
    (("" (name "ALPH" "max(abs(x!1), abs(xp!1))")
      (("" (case "ALPH /= 0")
        (("1" (flatten)
          (("1" (expand "A2seq")
            (("1" (replace -1)
              (("1" (hide -1)
                (("1" (lemma "conv_derivseq")
                  (("1" (inst - "derivseq(a!1)")
                    (("1" (split -1)
                      (("1" (lemma "conv_series_shift")
                        (("1"
                          (inst - "2" "(LAMBDA (k):
                                                IF k < 2 THEN k
                                                ELSE abs(k) * abs(k - 1) *
                                                      abs(a!1(k) * ALPH ^ (k - 2))
                                                ENDIF)")
                          (("1" (assert)
                            (("1" (lemma "end_series_conv")
                              (("1"
                                (inst?)
                                (("1"
                                  (assert)
                                  (("1"
                                    (hide 1 5)
                                    (("1"
                                      (lemma "A2_prep")
                                      (("1"
                                        (inst - "a!1" "ALPH")
                                        (("1"
                                          (split -1)
                                          (("1"
                                            (case-replace
                                             "abs(powerseq((LAMBDA
                                                                                      n:
                                                                                      (1 + n) * (2 + n) * a!1(2 + n)),
                                                                                     ALPH)) = powerseq((LAMBDA
                                                                                      n:
                                                                                      abs(1 + n) * abs(2 + n) * abs(a!1(2 + n))),
                                                                                     abs(ALPH))")
                                            (("1"
                                              (hide -1)
                                              (("1"
                                                (case-replace
                                                 "abs(ALPH) = ALPH")
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (case-replace
                                                     "(LAMBDA (k: nat):
                                                                                          IF k = 0 THEN abs(1) * abs(2) * abs(a!1(2))
                                                                                          ELSE abs(a!1(2 + k)) * abs(1 + k) * abs(2 + k) *
                                                                                                ALPH ^ k
                                                                                          ENDIF)
                                                                                   = (LAMBDA n:
                                                                                          abs(1 + n) * abs(2 + n) *
                                                                                           abs(a!1(2 + n) * ALPH ^ n))")
                                                    (("1"
                                                      (ground)
                                                      (("1"
                                                        (hide 3)
                                                        (("1"
                                                          (case-replace
                                                           "abs(ALPH) = ALPH")
                                                          (("1"
                                                            (hide
                                                             -2
                                                             -3
                                                             -4
                                                             -5
                                                             2
                                                             4)
                                                            (("1"
                                                              (replace
                                                               -1
                                                               *
                                                               rl)
                                                              (("1"
                                                                (postpone)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (postpone)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (postpone)
                                                  nil
                                                  nil))
                                                nil))
                                              nil)
                                             ("2" (postpone) nil nil))
                                            nil)
                                           ("2" (postpone) nil nil))
                                          nil)
                                         ("2" (postpone) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (postpone) nil nil))
                          nil))
                        nil)
                       ("2" (postpone) nil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (postpone) nil nil))
        nil))
      nil))
    nil)
   nil nil)
  (A2_conv-2 "asdf" 3299518193
   ("" (skosimp*)
    (("" (name "ALPH" "max(abs(x!1), abs(xp!1))")
      (("" (case "ALPH /= 0")
        (("1" (flatten)
          (("1" (expand "A2seq")
            (("1" (replace -1)
              (("1" (hide -1)
                (("1" (lemma "conv_derivseq")
                  (("1" (inst - "derivseq(a!1)")
                    (("1" (split -1)
                      (("1" (lemma "conv_series_shift")
                        (("1"
                          (inst - "2" "(LAMBDA (k):
                                                IF k < 2 THEN k
                                                ELSE abs(k) * abs(k - 1) *
                                                      abs(a!1(k) * ALPH ^ (k - 2))
                                                ENDIF)")
                          (("1" (assert)
                            (("1" (lemma "end_series_conv")
                              (("1"
                                (inst?)
                                (("1"
                                  (assert)
                                  (("1"
                                    (hide 1 5)
                                    (("1"
                                      (lemma "A2_prep")
                                      (("1"
                                        (inst - "a!1" "ALPH")
                                        (("1" (postpone) nil nil)
                                         ("2" (postpone) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (skosimp*) nil nil))
                          nil))
                        nil)
                       ("2" (assert)
                        (("2" (hide 4)
                          (("2" (lemma "conv_derivseq")
                            (("2" (inst - "a!1")
                              (("2" (assertnil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (assert)
          (("2" (flatten)
            (("2" (hide -3 2) (("2" (grind) nil nil)) nil)) nil))
          nil))
        nil))
      nil))
    nil)
   nil nil)
  (asdf "asdf" 3299518171
   ("" (skosimp*)
    (("" (name "ALPH" "max(abs(x!1), abs(xp!1))")
      (("" (case "ALPH /= 0")
        (("1" (flatten)
          (("1" (expand "A2seq")
            (("1" (replace -1)
              (("1" (hide -1)
                (("1" (lemma "conv_derivseq")
                  (("1" (inst - "derivseq(a!1)")
                    (("1" (split -1)
                      (("1" (lemma "conv_series_shift")
                        (("1"
                          (inst - "2" "(LAMBDA (k):
                                          IF k < 2 THEN k
                                          ELSE abs(k) * abs(k - 1) *
                                                abs(a!1(k) * ALPH ^ (k - 2))
                                          ENDIF)")
                          (("1" (assert)
                            (("1" (lemma "end_series_conv")
                              (("1"
                                (inst?)
                                (("1"
                                  (assert)
                                  (("1"
                                    (hide 1 5)
                                    (("1"
                                      (lemma "A2_prep")
                                      (("1"
                                        (inst - "a!1" "ALPH")
                                        (("1"
                                          (lemma
                                           "powerseries_conv_abs")
                                          (("1"
                                            (inst
                                             -
                                             "(LAMBDA n: (1 + n) * (2 + n) * a!1(2 + n))")
                                            (("1"
                                              (split -1)
                                              (("1" (postpone) nil nil)
                                               ("2"
                                                (skosimp*)
                                                (("2"
                                                  (typepred "x!2")
                                                  (("2"
                                                    (postpone)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (hide 2 4)
                                          (("2" (postpone) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (skosimp*) nil nil))
                          nil))
                        nil)
                       ("2" (assert)
                        (("2" (hide 4)
                          (("2" (lemma "conv_derivseq")
                            (("2" (inst - "a!1")
                              (("2" (assertnil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (assert)
          (("2" (flatten)
            (("2" (hide -3 2) (("2" (grind) nil nil)) nil)) nil))
          nil))
        nil))
      nil))
    nil)
   nil shostak)
  (A2_conv-1 nil 3299500900
   ("" (skosimp*)
    (("" (name "ALPH" "max(abs(x!1), abs(xp!1))")
      (("" (case "ALPH /= 0")
        (("1" (flatten)
          (("1" (expand "A2seq")
            (("1" (replace -1)
              (("1" (hide -1)
                (("1" (lemma "conv_derivseq")
                  (("1" (inst - "derivseq(a!1)")
                    (("1" (split -1)
                      (("1" (lemma "conv_series_shift")
                        (("1"
                          (inst - "2" "(LAMBDA (k):
                                          IF k < 2 THEN k
                                          ELSE abs(k) * abs(k - 1) *
                                                abs(a!1(k) * ALPH ^ (k - 2))
                                          ENDIF)")
                          (("1" (assert)
                            (("1" (lemma "end_series_conv")
                              (("1"
                                (inst?)
                                (("1"
                                  (assert)
                                  (("1"
                                    (hide 1 5)
                                    (("1"
                                      (lemma "A2_prep")
                                      (("1"
                                        (inst - "a!1" "ALPH")
                                        (("1"
                                          (lemma
                                           "powerseries_conv_abs")
                                          (("1"
                                            (inst
                                             -
                                             "(LAMBDA n: (1 + n) * (2 + n) * a!1(2 + n))")
                                            (("1"
                                              (split -1)
                                              (("1"
                                                (inst - "ALPH")
                                                (("1"
                                                  (case-replace
                                                   "abs(powerseq((LAMBDA
                                                                          n:
                                                                          (1 + n) * (2 + n) * a!1(2 + n)),
                                                                         ALPH)) = powerseq((LAMBDA
                                                                          n:
                                                                          abs(1 + n) * abs(2 + n) * abs(a!1(2 + n))),
                                                                         abs(ALPH))")
                                                  (("1"
                                                    (hide -1)
                                                    (("1"
                                                      (case-replace
                                                       "abs(ALPH) = ALPH")
                                                      (("1"
                                                        (expand
                                                         "powerseq")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (case-replace
                                                             "(LAMBDA (k: nat):
                                                                          IF k = 0 THEN abs(1) * abs(2) * abs(a!1(2))
                                                                          ELSE abs(a!1(2 + k)) * abs(1 + k) * abs(2 + k) *
                                                                                ALPH ^ k
                                                                          ENDIF)
                                                                   = (LAMBDA n:
                                                                          abs(1 + n) * abs(2 + n) *
                                                                           abs(a!1(2 + n) * ALPH ^ n))")
                                                            (("1"
                                                              (apply-extensionality
                                                               1
                                                               :hide?
                                                               t)
                                                              (("1"
                                                                (lift-if)
                                                                (("1"
                                                                  (ground)
                                                                  (("1"
                                                                    (replace
                                                                     -1)
                                                                    (("1"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (hide
                                                                     3)
                                                                    (("2"
                                                                      (rewrite
                                                                       "abs_mult")
                                                                      (("2"
                                                                        (assert)
                                                                        (("2"
                                                                          (rewrite
                                                                           "abs_hat")
                                                                          (("2"
                                                                            (case-replace
                                                                             "abs(ALPH) = ALPH")
                                                                            (("2"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (reveal -8)
                                                        (("2"
                                                          (hide
                                                           -2
                                                           -3
                                                           -4
                                                           -5
                                                           2
                                                           4)
                                                          (("2"
                                                            (replace
                                                             -1
                                                             *
                                                             rl)
                                                            (("2"
                                                              (grind)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (hide 2 4)
                                                    (("2"
                                                      (hide -)
                                                      (("2"
                                                        (lemma
                                                         "ABC_LEM")
                                                        (("2"
                                                          (inst?)
                                                          (("1"
                                                            (replace
                                                             -1)
                                                            (("1"
                                                              (hide -1)
                                                              (("1"
                                                                (case-replace
                                                                 "abs((LAMBDA n: (1 + n) * (2 + n) * a!1(2 + n))) = (LAMBDA n: abs(1 + n) * abs(2 + n) * abs(a!1(2 + n)))")
                                                                (("1"
                                                                  (hide
                                                                   2)
                                                                  (("1"
                                                                    (case-replace
                                                                     "abs((LAMBDA n: (1 + n) * (2 + n) * a!1(2 + n))) = abs(fseq(a!1))")
                                                                    (("1"
                                                                      (hide
                                                                       -1)
                                                                      (("1"
                                                                        (apply-extensionality
                                                                         1
                                                                         :hide?
                                                                         t)
                                                                        (("1"
                                                                          (expand
                                                                           "abs"
                                                                           1
                                                                           1)
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (case-replace
                                                                               "fseq(a!1)(x!2) =  (1 + x!2) * (2 + x!2) * a!1(2 + x!2)")
                                                                              (("1"
                                                                                (rewrite
                                                                                 "abs_mult")
                                                                                (("1"
                                                                                  (hide
                                                                                   -1)
                                                                                  (("1"
                                                                                    (case-replace
                                                                                     "2 + x!2 + (x!2 * x!2 + 2 * x!2) = (2+x!2)*(1+x!2)")
                                                                                    (("1"
                                                                                      (rewrite
                                                                                       "abs_mult")
                                                                                      (("1"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (expand
                                                                                 "fseq")
                                                                                (("2"
                                                                                  (propax)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (hide
                                                                       2)
                                                                      (("2"
                                                                        (expand
                                                                         "fseq")
                                                                        (("2"
                                                                          (propax)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("3"
                                                                      (skosimp*)
                                                                      (("3"
                                                                        (assert)
                                                                        (("3"
                                                                          (hide
                                                                           2)
                                                                          (("3"
                                                                            (grind)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("4"
                                                                      (skosimp*)
                                                                      (("4"
                                                                        (hide
                                                                         2
                                                                         3)
                                                                        (("4"
                                                                          (assert)
                                                                          (("4"
                                                                            (grind)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (reveal
                                                             -12)
                                                            (("2"
                                                              (hide 2)
                                                              (("2"
                                                                (lemma
                                                                 "ball")
                                                                (("2"
                                                                  (inst
                                                                   -
                                                                   "x!1")
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (lemma
                                                                       "ball")
                                                                      (("2"
                                                                        (inst
                                                                         -
                                                                         "xp!1")
                                                                        (("2"
                                                                          (assert)
                                                                          (("2"
                                                                            (grind)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (hide 2 4)
                                                (("2"
                                                  (replace -3)
                                                  (("2"
                                                    (skosimp*)
                                                    (("2"
                                                      (typepred "x!2")
                                                      (("2"
                                                        (postpone)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (hide 2 4)
                                          (("2" (postpone) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (skosimp*) nil nil))
                          nil))
                        nil)
                       ("2" (assert)
                        (("2" (hide 4)
                          (("2" (lemma "conv_derivseq")
                            (("2" (inst - "a!1")
                              (("2" (assertnil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (assert)
          (("2" (flatten)
            (("2" (hide -3 2) (("2" (grind) nil nil)) nil)) nil))
          nil))
        nil))
      nil))
    nil)
   nil shostak))
 (Gseq_conv 0
  (Gseq_conv-6 nil 3445341743
   ("" (skosimp*)
    (("" (expand "conv_series?")
      (("" (expand "Gseq")
        ((""
          (case "FORALL (k: above(1)): abs(x!1 - GET_tk(x!1, h!1, k)) < abs(h!1)")
          (("1" (lemma "comparison_test_gen")
            (("1" (name "ALPH" "max(abs(x!1),abs(x!1+h!1))")
              (("1" (lemma "end_series_conv")
                (("1" (inst?)
                  (("1" (assert)
                    (("1" (hide 2)
                      (("1" (assert)
                        (("1"
                          (inst - "(LAMBDA (k):
                                                              IF k < 2 THEN k * a!1(k)
                                                              ELSE k * a!1(k) * GET_tk(x!1, h!1, k) ^ (k - 1) -
                                                                    k * a!1(k) * x!1 ^ (k - 1)
                                                              ENDIF)"
                           "(LAMBDA (k): IF k < 2 THEN 0 ELSE abs(h!1*k)*abs(k-1)*abs(a!1(k)*ALPH^(k-2)) ENDIF)")
                          (("1" (assert)
                            (("1" (hide 1)
                              (("1"
                                (split +)
                                (("1"
                                  (hide -1 -2)
                                  (("1"
                                    (case-replace
                                     "(LAMBDA (k):
                                               IF k < 2 THEN 0
                                               ELSE abs(k - 1) * abs(a!1(k) * ALPH ^ (k - 2)) *
                                                     abs(h!1 * k)
                                               ENDIF) =
                                     (LAMBDA (k): abs(h!1)*
                                               IF k < 2 THEN 0
                                               ELSE abs(k)*abs(k - 1) * abs(a!1(k)) * abs(ALPH ^ (k - 2))
                                               ENDIF)")
                                    (("1"
                                      (hide -1)
                                      (("1"
                                        (lemma "conv_scaf0")
                                        (("1"
                                          (inst?)
                                          (("1"
                                            (inst - "ALPH")
                                            (("1"
                                              (assert)
                                              (("1"
                                                (lemma
                                                 "conv_series_scal")
                                                (("1"
                                                  (inst?)
                                                  (("1"
                                                    (inst - "abs(h!1)")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (rewrite
                                                         "series_scal")
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (assert)
                                              (("2"
                                                (reveal -4)
                                                (("2"
                                                  (replace -1 * rl)
                                                  (("2"
                                                    (hide -1 -2 2)
                                                    (("2"
                                                      (typepred "h!1")
                                                      (("2"
                                                        (expand "A")
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (lemma
                                                             "ball")
                                                            (("2"
                                                              (inst
                                                               -
                                                               "(h!1 + x!1)")
                                                              (("2"
                                                                (lemma
                                                                 "ball")
                                                                (("2"
                                                                  (inst
                                                                   -
                                                                   "(x!1)")
                                                                  (("2"
                                                                    (grind)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (hide 2)
                                      (("2"
                                        (apply-extensionality
                                         1
                                         :hide?
                                         t)
                                        (("2"
                                          (lift-if)
                                          (("2"
                                            (rewrite "abs_mult")
                                            (("2"
                                              (rewrite "abs_mult")
                                              (("2" (ground) nil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (inst 1 "3")
                                  (("2"
                                    (skosimp*)
                                    (("2"
                                      (lift-if)
                                      (("2"
                                        (ground)
                                        (("2"
                                          (inst -3 "n!1")
                                          (("2"
                                            (name
                                             "TK"
                                             "GET_tk(x!1, h!1, n!1)")
                                            (("2"
                                              (case
                                               "(EXISTS (PKM1: between[T](x!1,TK)):
                                                                                                           abs(x!1^(n!1-1) - TK^(n!1-1)) =
                                                                                                              abs(x!1 - TK)*abs(n!1-1)*abs(PKM1^(n!1-2)))")
                                              (("1"
                                                (skosimp*)
                                                (("1"
                                                  (replace -2)
                                                  (("1"
                                                    (case
                                                     "abs(PKM1!1) <= abs(ALPH)")
                                                    (("1"
                                                      (case
                                                       "abs(a!1(n!1) * TK ^(n!1 - 1) * n!1 -
                                                                                                          a!1(n!1) * x!1 ^ (n!1 - 1) * n!1) =
                                                                                                       abs(a!1(n!1))*abs(n!1)*abs(TK ^ (n!1 - 1) - x!1 ^ (n!1 - 1))")
                                                      (("1"
                                                        (replace -1)
                                                        (("1"
                                                          (hide -1)
                                                          (("1"
                                                            (rewrite
                                                             "abs_mult")
                                                            (("1"
                                                              (rewrite
                                                               "abs_mult")
                                                              (("1"
                                                                (auto-rewrite
                                                                 "abs_0")
                                                                (("1"
                                                                  (case-replace
                                                                   "ALPH = 0")
                                                                  (("1"
                                                                    (hide-all-but
                                                                     -6)
                                                                    (("1"
                                                                      (grind)
                                                                      nil
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (div-by
                                                                     3
                                                                     "abs(n!1)*abs(n!1-1)")
                                                                    (("1"
                                                                      (field
                                                                       3)
                                                                      (("1"
                                                                        (lemma
                                                                         "abs_neg")
                                                                        (("1"
                                                                          (inst
                                                                           -
                                                                           "(x!1 ^ (n!1 - 1) - TK ^ (n!1 - 1))")
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (replace
                                                                               -1)
                                                                              (("1"
                                                                                (replace
                                                                                 -5)
                                                                                (("1"
                                                                                  (div-by
                                                                                   3
                                                                                   "abs(n!1-1)")
                                                                                  (("1"
                                                                                    (field
                                                                                     3)
                                                                                    (("1"
                                                                                      (hide
                                                                                       -1
                                                                                       -3-6
                                                                                       -7
                                                                                       -10)
                                                                                      (("1"
                                                                                        (lemma
                                                                                         "both_sides_expt_pos_ge")
                                                                                        (("1"
                                                                                          (inst
                                                                                           -
                                                                                           "(n!1-2)"
                                                                                           "abs(ALPH)"
                                                                                           "abs(PKM1!1)")
                                                                                          (("1"
                                                                                            (assert)
                                                                                            (("1"
                                                                                              (rewrite
                                                                                               "abs_hat"
                                                                                               :dir
                                                                                               rl)
                                                                                              (("1"
                                                                                                (div-by
                                                                                                 3
                                                                                                 "abs(a!1(n!1))")
                                                                                                (("1"
                                                                                                  (field
                                                                                                   3)
                                                                                                  (("1"
                                                                                                    (case-replace
                                                                                                     "PKM1!1 = 0")
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      nil
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (assert)
                                                                                                      (("2"
                                                                                                        (case
                                                                                                         "abs(PKM1!1) /= 0")
                                                                                                        (("1"
                                                                                                          (flatten)
                                                                                                          (("1"
                                                                                                            (rewrite
                                                                                                             "abs_hat"
                                                                                                             :dir
                                                                                                             rl)
                                                                                                            (("1"
                                                                                                              (div-by
                                                                                                               4
                                                                                                               "abs(a!1(n!1))")
                                                                                                              (("1"
                                                                                                                (field
                                                                                                                 4)
                                                                                                                (("1"
                                                                                                                  (mult-ineq
                                                                                                                   -2
                                                                                                                   -8)
                                                                                                                  (("1"
                                                                                                                    (assert)
                                                                                                                    nil
                                                                                                                    nil)
                                                                                                                   ("2"
                                                                                                                    (auto-rewrite
                                                                                                                     "abs_abs")
                                                                                                                    (("2"
                                                                                                                      (assert)
                                                                                                                      nil
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (lemma
                                                                                                           "abs_eq_0")
                                                                                                          (("2"
                                                                                                            (inst
                                                                                                             -
                                                                                                             "PKM1!1")
                                                                                                            (("2"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (assert)
                                                                                            (("2"
                                                                                              (case
                                                                                               "abs(PKM1!1) /= 0")
                                                                                              (("1"
                                                                                                (flatten)
                                                                                                (("1"
                                                                                                  (rewrite
                                                                                                   "abs_eq_0")
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil)
                                                                                               ("2"
                                                                                                (flatten)
                                                                                                (("2"
                                                                                                  (case-replace
                                                                                                   "PKM1!1 = 0")
                                                                                                  (("1"
                                                                                                    (case-replace
                                                                                                     "PKM1!1 = 0")
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil)
                                                                                                   ("2"
                                                                                                    (lemma
                                                                                                     "abs_eq_0")
                                                                                                    (("2"
                                                                                                      (inst
                                                                                                       -
                                                                                                       "PKM1!1")
                                                                                                      (("2"
                                                                                                        (assert)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (assert)
                                                                      (("2"
                                                                        (hide-all-but
                                                                         (1
                                                                          3))
                                                                        (("2"
                                                                          (mult-cases
                                                                           1)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (hide 3)
                                                        (("2"
                                                          (hide-all-but
                                                           1)
                                                          (("2"
                                                            (case-replace
                                                             "a!1(n!1) * TK ^ (n!1 - 1) * n!1 -
                                                                                           a!1(n!1) * x!1 ^ (n!1 - 1) * n!1 =
                                                                                           a!1(n!1) * n!1*(TK ^(n!1 - 1) - x!1^(n!1 - 1))")
                                                            (("1"
                                                              (rewrite
                                                               "abs_mult")
                                                              (("1"
                                                                (rewrite
                                                                 "abs_mult")
                                                                nil
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (hide 2)
                                                              (("2"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (hide 3)
                                                      (("2"
                                                        (replace
                                                         -4
                                                         *
                                                         rl)
                                                        (("2"
                                                          (hide -4)
                                                          (("2"
                                                            (hide
                                                             -1
                                                             -2)
                                                            (("2"
                                                              (hide -3)
                                                              (("2"
                                                                (case-replace
                                                                 "abs(max(abs(x!1), abs(h!1 + x!1))) = (max(abs(x!1), abs(h!1 + x!1)))")
                                                                (("1"
                                                                  (hide
                                                                   -1)
                                                                  (("1"
                                                                    (hide
                                                                     -2)
                                                                    (("1"
                                                                      (typepred
                                                                       "TK")
                                                                      (("1"
                                                                        (hide
                                                                         -5)
                                                                        (("1"
                                                                          (typepred
                                                                           "PKM1!1")
                                                                          (("1"
                                                                            (grind)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (hide
                                                                   2)
                                                                  (("2"
                                                                    (grind)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (hide 3)
                                                (("2"
                                                  (lemma
                                                   "mean_value[T]")
                                                  (("1"
                                                    (inst
                                                     -
                                                     "TK"
                                                     "x!1"
                                                     "(LAMBDA (x:T): x^(n!1-1))")
                                                    (("1"
                                                      (lemma
                                                       "deriv_x_to_n[T]")
                                                      (("1"
                                                        (inst
                                                         -
                                                         "(n!1-1)"
                                                         "1")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (flatten)
                                                            (("1"
                                                              (case-replace
                                                               "(LAMBDA (x: T): 1 * x ^ (n!1 - 1)) = (LAMBDA (x: T): x ^ (n!1 - 1))")
                                                              (("1"
                                                                (hide
                                                                 -1)
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (split
                                                                     -3)
                                                                    (("1"
                                                                      (skosimp*)
                                                                      (("1"
                                                                        (inst
                                                                         +
                                                                         "c!1")
                                                                        (("1"
                                                                          (case-replace
                                                                           "deriv((LAMBDA (x: T): x ^ (n!1 - 1)), c!1) =
                                                                                 (n!1-1)*c!1^(n!1-2)")
                                                                          (("1"
                                                                            (factor
                                                                             -4
                                                                             l)
                                                                            (("1"
                                                                              (hide-all-but
                                                                               (-4
                                                                                1))
                                                                              (("1"
                                                                                (name-replace
                                                                                 "NM1"
                                                                                 "n!1-1")
                                                                                (("1"
                                                                                  (replace
                                                                                   -1
                                                                                   *
                                                                                   rl)
                                                                                  (("1"
                                                                                    (rewrite
                                                                                     "abs_mult")
                                                                                    (("1"
                                                                                      (rewrite
                                                                                       "abs_mult")
                                                                                      (("1"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (hide
                                                                             2)
                                                                            (("2"
                                                                              (lemma
                                                                               "deriv_x_to_n[T]")
                                                                              (("2"
                                                                                (assert)
                                                                                (("2"
                                                                                  (inst
                                                                                   -
                                                                                   "(n!1-1)"
                                                                                   "1")
                                                                                  (("2"
                                                                                    (flatten)
                                                                                    (("2"
                                                                                      (case-replace
                                                                                       "(LAMBDA (x: T): 1 * x ^ (n!1 - 1)) = (LAMBDA (x: T): x ^ (n!1 - 1))")
                                                                                      (("1"
                                                                                        (hide
                                                                                         -1)
                                                                                        (("1"
                                                                                          (replace
                                                                                           -2)
                                                                                          (("1"
                                                                                            (hide-all-but
                                                                                             (-1
                                                                                              -2
                                                                                              1))
                                                                                            (("1"
                                                                                              (assert)
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "deriv"
                                                                                                 -2)
                                                                                                (("1"
                                                                                                  (assert)
                                                                                                  (("1"
                                                                                                    (case-replace
                                                                                                     "(LAMBDA (x_1: T): deriv((LAMBDA (x: T): x ^ (n!1 - 1)), x_1))(c!1)
                                                 =
                                                       (LAMBDA (x: T): (x ^ (n!1 - 2)) * n!1 - x ^ (n!1 - 2))(c!1)")
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      nil
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (hide
                                                                                                       2)
                                                                                                      (("2"
                                                                                                        (replace
                                                                                                         -2)
                                                                                                        (("2"
                                                                                                          (propax)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("3"
                                                                                                      (lemma
                                                                                                       "not_one_element")
                                                                                                      (("3"
                                                                                                        (skosimp*)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("4"
                                                                                                      (skosimp*)
                                                                                                      (("4"
                                                                                                        (lemma
                                                                                                         deriv_domain)
                                                                                                        (("4"
                                                                                                          (propax)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("5"
                                                                                                      (hide
                                                                                                       -2
                                                                                                       2)
                                                                                                      (("5"
                                                                                                        (expand
                                                                                                         "derivable?"
                                                                                                         -1)
                                                                                                        (("5"
                                                                                                          (skosimp*)
                                                                                                          (("5"
                                                                                                            (inst?)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (apply-extensionality
                                                                                         1
                                                                                         :hide?
                                                                                         t)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (assert)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (case-replace
                                                                       "x!1 = TK")
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (rewrite
                                                                           "abs_0")
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (typepred
                                                                               "TK")
                                                                              (("1"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (lemma
                                                                         "mean_value[T]")
                                                                        (("2"
                                                                          (inst
                                                                           -
                                                                           "x!1"
                                                                           "TK"
                                                                           "(LAMBDA (x:T): x^(n!1-1))")
                                                                          (("2"
                                                                            (assert)
                                                                            (("2"
                                                                              (skosimp*)
                                                                              (("2"
                                                                                (inst
                                                                                 +
                                                                                 "c!1")
                                                                                (("1"
                                                                                  (case-replace
                                                                                   "deriv((LAMBDA (x: T): x ^ (n!1 - 1)), c!1) =
                                                                                                         (n!1-1)*c!1^(n!1-2)")
                                                                                  (("1"
                                                                                    (factor
                                                                                     -4
                                                                                     l)
                                                                                    (("1"
                                                                                      (hide-all-but
                                                                                       (-4
                                                                                        1
                                                                                        2
                                                                                        3))
                                                                                      (("1"
                                                                                        (name-replace
                                                                                         "NM1"
                                                                                         "n!1-1")
                                                                                        (("1"
                                                                                          (lemma
                                                                                           "abs_neg")
                                                                                          (("1"
                                                                                            (inst
                                                                                             -
                                                                                             "(x!1 - TK)")
                                                                                            (("1"
                                                                                              (replace
                                                                                               -1
                                                                                               *
                                                                                               rl)
                                                                                              (("1"
                                                                                                (name-replace
                                                                                                 "TKMx"
                                                                                                 "(TK - x!1)")
                                                                                                (("1"
                                                                                                  (hide
                                                                                                   -1)
                                                                                                  (("1"
                                                                                                    (case-replace
                                                                                                     "abs(x!1 ^ NM1 - TK ^ NM1) = abs(TK ^ NM1 - x!1 ^ NM1) ")
                                                                                                    (("1"
                                                                                                      (replace
                                                                                                       -2
                                                                                                       *
                                                                                                       rl)
                                                                                                      (("1"
                                                                                                        (hide
                                                                                                         -1
                                                                                                         -2)
                                                                                                        (("1"
                                                                                                          (rewrite
                                                                                                           "abs_mult")
                                                                                                          (("1"
                                                                                                            (rewrite
                                                                                                             "abs_mult")
                                                                                                            (("1"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (hide-all-but
                                                                                                       1)
                                                                                                      (("2"
                                                                                                        (expand
                                                                                                         "abs")
                                                                                                        (("2"
                                                                                                          (lift-if)
                                                                                                          (("2"
                                                                                                            (lift-if)
                                                                                                            (("2"
                                                                                                              (ground)
                                                                                                              (("2"
                                                                                                                (lift-if)
                                                                                                                (("2"
                                                                                                                  (ground)
                                                                                                                  nil
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil)
                                                                                   ("2"
                                                                                    (case-replace
                                                                                     "deriv((LAMBDA (x: T): x ^ (n!1 - 1)), c!1) = deriv(LAMBDA (x: T): x ^ (n!1 - 1))(c!1)")
                                                                                    (("1"
                                                                                      (replace
                                                                                       -6)
                                                                                      (("1"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (expand
                                                                                       "deriv"
                                                                                       1
                                                                                       2)
                                                                                      (("2"
                                                                                        (propax)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (apply-extensionality
                                                                 1
                                                                 :hide?
                                                                 t)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (lemma
                                                         "connected_domain")
                                                        (("2"
                                                          (lemma
                                                           "connected_deriv_domain[T]")
                                                          (("2"
                                                            (replace
                                                             -2)
                                                            (("2"
                                                              (lemma
                                                               deriv_domain)
                                                              (("2"
                                                                (propax)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (lemma
                                                     "not_one_element")
                                                    (("2"
                                                      (propax)
                                                      nil
                                                      nil))
                                                    nil)
                                                   ("3"
                                                    (lemma
                                                     "connected_domain")
                                                    (("3"
                                                      (propax)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (skosimp*) (("2" (assertnil nil))
                            nil)
                           ("3" (skosimp*) (("3" (assertnil nil))
                            nil)
                           ("4" (skosimp*) (("4" (assertnil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (skosimp*) (("2" (assertnil nil)) nil)
                   ("3" (skosimp*) (("3" (assertnil nil)) nil)
                   ("4" (skosimp*) (("4" (assertnil nil)) nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (hide 2)
            (("2" (skosimp*)
              (("2" (typepred "GET_tk(x!1, h!1, k!1)")
                (("2" (name-replace "TK" "GET_tk(x!1, h!1, k!1)")
                  (("2" (grind) nil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((conv_series? const-decl "bool" series nil)
    (GET_tk const-decl
     "{tk: between[T](x, x + h) | ((x + h) ^ k - x ^ k) / h = k * tk ^ (k - 1)}"
     power_series_deriv_scaf 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, nznum -> numfield]" number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (between type-eq-decl nil taylors "analysis/")
    (= const-decl "[T, T -> boolean]" equalities nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (A const-decl "setof[nzreal]" derivatives_def "analysis/")
    (setof type-eq-decl nil defined_types nil)
    (nzreal nonempty-type-eq-decl nil reals nil)
    (/= const-decl "boolean" notequal nil)
    (T formal-subtype-decl nil power_series_deriv_scaf nil)
    (T_pred const-decl "[real -> boolean]" power_series_deriv_scaf nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (>= const-decl "bool" reals nil) (< const-decl "bool" reals nil)
    (above nonempty-type-eq-decl nil integers 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)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (nonneg_real_max application-judgement
     "{z: nonneg_real | z >= x AND z >= y}" real_defs nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (x!1 skolem-const-decl "T" power_series_deriv_scaf nil)
    (h!1 skolem-const-decl "(A(x!1))" power_series_deriv_scaf nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (sequence type-eq-decl nil sequences nil)
    (nnreal_times_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (nnreal_exp application-judgement "nnreal" exponentiation nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (minus_nzreal_is_nzreal application-judgement "nzreal" real_types
     nil)
    (nnrat_exp application-judgement "nnrat" exponentiation nil)
    (pos_times_gt formula-decl nil real_props nil)
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (both_sides_times_pos_le1 formula-decl nil real_props nil)
    (FDX_6 skolem-const-decl
     "{n: nonneg_real | n >= n!1 - 1 AND n >= -(n!1 - 1)}"
     power_series_deriv_scaf nil)
    (div_cancel2 formula-decl nil real_props nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (bijective? const-decl "bool" functions nil)
    (id const-decl "(bijective?[T, T])" identity nil)
    (TRUE const-decl "bool" booleans nil)
    (FDX_7 skolem-const-decl
     "{n: nonneg_real | n >= n!1 - 1 AND n >= -(n!1 - 1)}"
     power_series_deriv_scaf nil)
    (both_sides_expt_pos_ge formula-decl nil exponentiation nil)
    (times_div_cancel1 formula-decl nil extra_real_props nil)
    (nat_exp application-judgement "nat" exponentiation nil)
    (zero_hat formula-decl nil exponent_props "reals/")
    (abs_0 formula-decl nil abs_lems "reals/")
    (le_times_le_pos formula-decl nil real_props nil)
    (nzreal_div_nzreal_is_nzreal application-judgement "nzreal"
     real_types nil)
    (both_sides_div_pos_lt1 formula-decl nil real_props nil)
    (abs_eq_0 formula-decl nil abs_lems "reals/")
    (abs_hat formula-decl nil exponent_props "reals/")
    (PKM1!1 skolem-const-decl "between[T](x!1, TK)"
     power_series_deriv_scaf nil)
    (TK skolem-const-decl "{tk: between[T](x!1, h!1 + x!1) |
         ((h!1 + x!1) ^ n!1 - x!1 ^ n!1) / h!1 = n!1 * tk ^ (n!1 - 1)}"
     power_series_deriv_scaf nil)
    (abs_neg formula-decl nil abs_lems "reals/")
    (n!1 skolem-const-decl "nat" power_series_deriv_scaf nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (both_sides_div_pos_le1 formula-decl nil real_props nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (<= const-decl "bool" reals nil)
    (mean_value formula-decl nil derivative_props "analysis/")
    (connected? const-decl "bool" deriv_domain_def "analysis/")
    (not_one_element? const-decl "bool" deriv_domain_def "analysis/")
    (deriv_x_to_n formula-decl nil derivatives "analysis/")
    (deriv_domain? const-decl "bool" deriv_domain_def "analysis/")
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (deriv_fun type-eq-decl nil derivatives "analysis/")
    (c!1 skolem-const-decl "T" power_series_deriv_scaf nil)
    (deriv const-decl "real" derivatives_def "analysis/")
    (derivable? const-decl "bool" derivatives_def "analysis/")
    (derivable? const-decl "bool" derivatives "analysis/")
    (deriv_domain formula-decl nil power_series_deriv_scaf nil)
    (not_one_element formula-decl nil power_series_deriv_scaf nil)
    (deriv const-decl "[T -> real]" derivatives "analysis/")
    (c!1 skolem-const-decl "T" power_series_deriv_scaf nil)
    (connected_deriv_domain formula-decl nil deriv_domain_def
     "analysis/")
    (connected_domain formula-decl nil power_series_deriv_scaf nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (abs_mult formula-decl nil real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_abs_is_nonneg application-judgement "{j: nonneg_int | j >= i}"
     real_defs nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (minus_real_is_real application-judgement "real" reals nil)
    (ball formula-decl nil power_series_deriv_scaf nil)
    (series_scal formula-decl nil series nil)
    (nonzero_abs_is_pos application-judgement "{y: posreal | y >= x}"
     real_defs nil)
    (conv_series_scal formula-decl nil series nil)
    (ALPH skolem-const-decl
     "{z: nonneg_real | z >= abs(x!1) AND z >= abs(h!1 + x!1)}"
     power_series_deriv_scaf nil)
    (conv_scaf0 formula-decl nil power_series_deriv_scaf nil)
    (end_series_conv formula-decl nil series nil)
    (comparison_test_gen formula-decl nil series nil)
    (expt def-decl "real" exponentiation nil)
    (Gseq const-decl "real" power_series_deriv_scaf nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_minus_real_is_real application-judgement "real" reals nil))
   nil)
  (Gseq_conv-5 nil 3299840221
   ("" (skosimp*)
    (("" (expand "conv_series?")
      (("" (expand "Gseq")
        ((""
          (case "FORALL (k: above(1)): abs(x!1 - GET_tk(x!1, h!1, k)) < abs(h!1)")
          (("1" (lemma "comparison_test_gen")
            (("1" (name "ALPH" "max(abs(x!1),abs(x!1+h!1))")
              (("1" (lemma "end_series_conv")
                (("1" (inst?)
                  (("1" (assert)
                    (("1" (hide 2)
                      (("1" (assert)
                        (("1"
                          (inst - "(LAMBDA (k):
                                                        IF k < 2 THEN k * a!1(k)
                                                        ELSE k * a!1(k) * GET_tk(x!1, h!1, k) ^ (k - 1) -
                                                              k * a!1(k) * x!1 ^ (k - 1)
                                                        ENDIF)"
                           "(LAMBDA (k): IF k < 2 THEN 0 ELSE abs(h!1*k)*abs(k-1)*abs(a!1(k)*ALPH^(k-2)) ENDIF)")
                          (("1" (assert)
                            (("1" (hide 1)
                              (("1"
                                (split +)
                                (("1"
                                  (hide -1 -2)
                                  (("1"
                                    (case-replace
                                     "(LAMBDA (k):
                                     IF k < 2 THEN 0
                                     ELSE abs(k - 1) * abs(a!1(k) * ALPH ^ (k - 2)) *
                                           abs(h!1 * k)
                                     ENDIF) =
                           (LAMBDA (k): abs(h!1)*
                                     IF k < 2 THEN 0
                                     ELSE abs(k)*abs(k - 1) * abs(a!1(k)) * abs(ALPH ^ (k - 2))

                                     ENDIF)")
                                    (("1"
                                      (hide -1)
                                      (("1"
                                        (lemma "conv_scaf0")
                                        (("1"
                                          (inst?)
                                          (("1"
                                            (inst - "ALPH")
                                            (("1"
                                              (assert)
                                              (("1"
                                                (lemma
                                                 "conv_series_scal")
                                                (("1"
                                                  (inst?)
                                                  (("1"
                                                    (inst - "abs(h!1)")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (rewrite
                                                         "series_scal")
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (assert)
                                              (("2"
                                                (reveal -4)
                                                (("2"
                                                  (replace -1 * rl)
                                                  (("2"
                                                    (hide -1 -2 2)
                                                    (("2"
                                                      (typepred "h!1")
                                                      (("2"
                                                        (expand "A")
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (lemma
                                                             "ball")
                                                            (("2"
                                                              (inst
                                                               -
                                                               "(h!1 + x!1)")
                                                              (("2"
                                                                (lemma
                                                                 "ball")
                                                                (("2"
                                                                  (inst
                                                                   -
                                                                   "(x!1)")
                                                                  (("2"
                                                                    (grind)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (hide 2)
                                      (("2"
                                        (apply-extensionality
                                         1
                                         :hide?
                                         t)
                                        (("2"
                                          (lift-if)
                                          (("2"
                                            (rewrite "abs_mult")
                                            (("2"
                                              (rewrite "abs_mult")
                                              (("2" (ground) nil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (inst 1 "3")
                                  (("2"
                                    (skosimp*)
                                    (("2"
                                      (lift-if)
                                      (("2"
                                        (ground)
                                        (("2"
                                          (inst -3 "n!1")
                                          (("2"
                                            (name
                                             "TK"
                                             "GET_tk(x!1, h!1, n!1)")
                                            (("2"
                                              (case
                                               "(EXISTS (PKM1: between[T](x!1,TK)):
                                                                                            abs(x!1^(n!1-1) - TK^(n!1-1)) =
                                                                                               abs(x!1 - TK)*abs(n!1-1)*abs(PKM1^(n!1-2)))")
                                              (("1"
                                                (skosimp*)
                                                (("1"
                                                  (replace -2)
                                                  (("1"
                                                    (case
                                                     "abs(PKM1!1) <= abs(ALPH)")
                                                    (("1"
                                                      (case
                                                       "abs(a!1(n!1) * TK ^(n!1 - 1) * n!1 -
                                                                                       a!1(n!1) * x!1 ^ (n!1 - 1) * n!1) =
                                                                                    abs(a!1(n!1))*abs(n!1)*abs(TK ^ (n!1 - 1) - x!1 ^ (n!1 - 1))")
                                                      (("1"
                                                        (replace -1)
                                                        (("1"
                                                          (hide -1)
                                                          (("1"
                                                            (rewrite
                                                             "abs_mult")
                                                            (("1"
                                                              (rewrite
                                                               "abs_mult")
                                                              (("1"
                                                                (auto-rewrite
                                                                 "abs_0")
                                                                (("1"
                                                                  (case-replace
                                                                   "ALPH = 0")
                                                                  (("1"
                                                                    (hide-all-but
                                                                     -6)
                                                                    (("1"
                                                                      (grind)
                                                                      nil
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (div-by
                                                                     3
                                                                     "abs(n!1)*abs(n!1-1)")
                                                                    (("1"
                                                                      (field
                                                                       3)
                                                                      (("1"
                                                                        (lemma
                                                                         "abs_neg")
                                                                        (("1"
                                                                          (inst
                                                                           -
                                                                           "(x!1 ^ (n!1 - 1) - TK ^ (n!1 - 1))")
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (replace
                                                                               -1)
                                                                              (("1"
                                                                                (replace
                                                                                 -5)
                                                                                (("1"
                                                                                  (div-by
                                                                                   3
                                                                                   "abs(n!1-1)")
                                                                                  (("1"
                                                                                    (field
                                                                                     3)
                                                                                    (("1"
                                                                                      (hide
                                                                                       -1
                                                                                       -3-6
                                                                                       -7
                                                                                       -10)
                                                                                      (("1"
                                                                                        (lemma
                                                                                         "both_sides_expt_pos_ge")
                                                                                        (("1"
                                                                                          (inst
                                                                                           -
                                                                                           "(n!1-2)"
                                                                                           "abs(ALPH)"
                                                                                           "abs(PKM1!1)")
                                                                                          (("1"
                                                                                            (assert)
                                                                                            (("1"
                                                                                              (rewrite
                                                                                               "abs_hat"
                                                                                               :dir
                                                                                               rl)
                                                                                              (("1"
                                                                                                (div-by
                                                                                                 3
                                                                                                 "abs(a!1(n!1))")
                                                                                                (("1"
                                                                                                  (field
                                                                                                   3)
                                                                                                  (("1"
                                                                                                    (case-replace
                                                                                                     "PKM1!1 = 0")
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      nil
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (assert)
                                                                                                      (("2"
                                                                                                        (case
                                                                                                         "abs(PKM1!1) /= 0")
                                                                                                        (("1"
                                                                                                          (flatten)
                                                                                                          (("1"
                                                                                                            (rewrite
                                                                                                             "abs_hat"
                                                                                                             :dir
                                                                                                             rl)
                                                                                                            (("1"
                                                                                                              (div-by
                                                                                                               4
                                                                                                               "abs(a!1(n!1))")
                                                                                                              (("1"
                                                                                                                (field
                                                                                                                 4)
                                                                                                                (("1"
                                                                                                                  (mult-ineq
                                                                                                                   -2
                                                                                                                   -8)
                                                                                                                  (("1"
                                                                                                                    (assert)
                                                                                                                    nil
                                                                                                                    nil)
                                                                                                                   ("2"
                                                                                                                    (auto-rewrite
                                                                                                                     "abs_abs")
                                                                                                                    (("2"
                                                                                                                      (assert)
                                                                                                                      nil
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (lemma
                                                                                                           "abs_eq_0")
                                                                                                          (("2"
                                                                                                            (inst
                                                                                                             -
                                                                                                             "PKM1!1")
                                                                                                            (("2"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (assert)
                                                                                            (("2"
                                                                                              (case
                                                                                               "abs(PKM1!1) /= 0")
                                                                                              (("1"
                                                                                                (flatten)
                                                                                                (("1"
                                                                                                  (rewrite
                                                                                                   "abs_eq_0")
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil)
                                                                                               ("2"
                                                                                                (flatten)
                                                                                                (("2"
                                                                                                  (case-replace
                                                                                                   "PKM1!1 = 0")
                                                                                                  (("1"
                                                                                                    (case-replace
                                                                                                     "PKM1!1 = 0")
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil)
                                                                                                   ("2"
                                                                                                    (lemma
                                                                                                     "abs_eq_0")
                                                                                                    (("2"
                                                                                                      (inst
                                                                                                       -
                                                                                                       "PKM1!1")
                                                                                                      (("2"
                                                                                                        (assert)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (assert)
                                                                      (("2"
                                                                        (hide-all-but
                                                                         (1
                                                                          3))
                                                                        (("2"
                                                                          (mult-cases
                                                                           1)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (hide 3)
                                                        (("2"
                                                          (hide-all-but
                                                           1)
                                                          (("2"
                                                            (case-replace
                                                             "a!1(n!1) * TK ^ (n!1 - 1) * n!1 -
                                                                           a!1(n!1) * x!1 ^ (n!1 - 1) * n!1 =
                                                                           a!1(n!1) * n!1*(TK ^(n!1 - 1) - x!1^(n!1 - 1))")
                                                            (("1"
                                                              (rewrite
                                                               "abs_mult")
                                                              (("1"
                                                                (rewrite
                                                                 "abs_mult")
                                                                nil
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (hide 2)
                                                              (("2"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (hide 3)
                                                      (("2"
                                                        (replace
                                                         -4
                                                         *
                                                         rl)
                                                        (("2"
                                                          (hide -4)
                                                          (("2"
                                                            (hide
                                                             -1
                                                             -2)
                                                            (("2"
                                                              (hide -3)
                                                              (("2"
                                                                (case-replace
                                                                 "abs(max(abs(x!1), abs(h!1 + x!1))) = (max(abs(x!1), abs(h!1 + x!1)))")
                                                                (("1"
                                                                  (hide
                                                                   -1)
                                                                  (("1"
                                                                    (hide
                                                                     -2)
                                                                    (("1"
                                                                      (typepred
                                                                       "TK")
                                                                      (("1"
                                                                        (hide
                                                                         -5)
                                                                        (("1"
                                                                          (typepred
                                                                           "PKM1!1")
                                                                          (("1"
                                                                            (grind)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (hide
                                                                   2)
                                                                  (("2"
                                                                    (grind)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (hide 3)
                                                (("2"
                                                  (lemma
                                                   "mean_value[T]")
                                                  (("1"
                                                    (inst
                                                     -
                                                     "TK"
                                                     "x!1"
                                                     "(LAMBDA (x:T): x^(n!1-1))")
                                                    (("1"
                                                      (lemma
                                                       "deriv_x_to_n[T]")
                                                      (("1"
                                                        (inst
                                                         -
                                                         "(n!1-1)"
                                                         "1")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (flatten)
                                                            (("1"
                                                              (case-replace
                                                               "(LAMBDA (x: T): 1 * x ^ (n!1 - 1)) = (LAMBDA (x: T): x ^ (n!1 - 1))")
                                                              (("1"
                                                                (hide
                                                                 -1)
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (split
                                                                     -3)
                                                                    (("1"
                                                                      (skosimp*)
                                                                      (("1"
                                                                        (inst
                                                                         +
                                                                         "c!1")
                                                                        (("1"
                                                                          (case-replace
                                                                           "deriv((LAMBDA (x: T): x ^ (n!1 - 1)), c!1) =
                                                             (n!1-1)*c!1^(n!1-2)")
                                                                          (("1"
                                                                            (factor
                                                                             -4
                                                                             l)
                                                                            (("1"
                                                                              (hide-all-but
                                                                               (-4
                                                                                1))
                                                                              (("1"
                                                                                (name-replace
                                                                                 "NM1"
                                                                                 "n!1-1")
                                                                                (("1"
                                                                                  (replace
                                                                                   -1
                                                                                   *
                                                                                   rl)
                                                                                  (("1"
                                                                                    (rewrite
                                                                                     "abs_mult")
                                                                                    (("1"
                                                                                      (rewrite
                                                                                       "abs_mult")
                                                                                      (("1"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (hide
                                                                             2)
                                                                            (("2"
                                                                              (lemma
                                                                               "deriv_x_to_n[T]")
                                                                              (("2"
                                                                                (assert)
                                                                                (("2"
                                                                                  (inst
                                                                                   -
                                                                                   "(n!1-1)"
                                                                                   "1")
                                                                                  (("2"
                                                                                    (flatten)
                                                                                    (("2"
                                                                                      (case-replace
                                                                                       "(LAMBDA (x: T): 1 * x ^ (n!1 - 1)) = (LAMBDA (x: T): x ^ (n!1 - 1))")
                                                                                      (("1"
                                                                                        (hide
                                                                                         -1)
                                                                                        (("1"
                                                                                          (replace
                                                                                           -2)
                                                                                          (("1"
                                                                                            (hide-all-but
                                                                                             (-1
                                                                                              -2
                                                                                              1))
                                                                                            (("1"
                                                                                              (assert)
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "deriv"
                                                                                                 -2)
                                                                                                (("1"
                                                                                                  (assert)
                                                                                                  (("1"
                                                                                                    (case-replace
                                                                                                     "(LAMBDA (x_1: T): deriv((LAMBDA (x: T): x ^ (n!1 - 1)), x_1))(c!1)
                         =
                               (LAMBDA (x: T): (x ^ (n!1 - 2)) * n!1 - x ^ (n!1 - 2))(c!1)")
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      nil
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (hide
                                                                                                       2)
                                                                                                      (("2"
                                                                                                        (replace
                                                                                                         -2)
                                                                                                        (("2"
                                                                                                          (propax)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("3"
                                                                                                      (lemma
                                                                                                       "not_one_element")
                                                                                                      (("3"
                                                                                                        (skosimp*)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("4"
                                                                                                      (lemma
                                                                                                       "connected_domain")
                                                                                                      (("4"
                                                                                                        (skosimp*)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("5"
                                                                                                      (hide
                                                                                                       -2
                                                                                                       2)
                                                                                                      (("5"
                                                                                                        (expand
                                                                                                         "derivable"
                                                                                                         -1)
                                                                                                        (("5"
                                                                                                          (skosimp*)
                                                                                                          (("5"
                                                                                                            (inst?)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (apply-extensionality
                                                                                         1
                                                                                         :hide?
                                                                                         t)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (assert)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (case-replace
                                                                       "x!1 = TK")
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (rewrite
                                                                           "abs_0")
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (typepred
                                                                               "TK")
                                                                              (("1"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (lemma
                                                                         "mean_value[T]")
                                                                        (("2"
                                                                          (inst
                                                                           -
                                                                           "x!1"
                                                                           "TK"
                                                                           "(LAMBDA (x:T): x^(n!1-1))")
                                                                          (("2"
                                                                            (assert)
                                                                            (("2"
                                                                              (skosimp*)
                                                                              (("2"
                                                                                (inst
                                                                                 +
                                                                                 "c!1")
                                                                                (("1"
                                                                                  (case-replace
                                                                                   "deriv((LAMBDA (x: T): x ^ (n!1 - 1)), c!1) =
                                                                                   (n!1-1)*c!1^(n!1-2)")
                                                                                  (("1"
                                                                                    (factor
                                                                                     -4
                                                                                     l)
                                                                                    (("1"
                                                                                      (hide-all-but
                                                                                       (-4
                                                                                        1
                                                                                        2
                                                                                        3))
                                                                                      (("1"
                                                                                        (name-replace
                                                                                         "NM1"
                                                                                         "n!1-1")
                                                                                        (("1"
                                                                                          (lemma
                                                                                           "abs_neg")
                                                                                          (("1"
                                                                                            (inst
                                                                                             -
                                                                                             "(x!1 - TK)")
                                                                                            (("1"
                                                                                              (replace
                                                                                               -1
                                                                                               *
                                                                                               rl)
                                                                                              (("1"
                                                                                                (name-replace
                                                                                                 "TKMx"
                                                                                                 "(TK - x!1)")
                                                                                                (("1"
                                                                                                  (hide
                                                                                                   -1)
                                                                                                  (("1"
                                                                                                    (case-replace
                                                                                                     "abs(x!1 ^ NM1 - TK ^ NM1) = abs(TK ^ NM1 - x!1 ^ NM1) ")
                                                                                                    (("1"
                                                                                                      (replace
                                                                                                       -2
                                                                                                       *
                                                                                                       rl)
                                                                                                      (("1"
                                                                                                        (hide
                                                                                                         -1
                                                                                                         -2)
                                                                                                        (("1"
                                                                                                          (rewrite
                                                                                                           "abs_mult")
                                                                                                          (("1"
                                                                                                            (rewrite
                                                                                                             "abs_mult")
                                                                                                            (("1"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (hide-all-but
                                                                                                       1)
                                                                                                      (("2"
                                                                                                        (expand
                                                                                                         "abs")
                                                                                                        (("2"
                                                                                                          (lift-if)
                                                                                                          (("2"
                                                                                                            (lift-if)
                                                                                                            (("2"
                                                                                                              (ground)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil)
                                                                                   ("2"
                                                                                    (case-replace
                                                                                     "deriv((LAMBDA (x: T): x ^ (n!1 - 1)), c!1) = deriv(LAMBDA (x: T): x ^ (n!1 - 1))(c!1)")
                                                                                    (("1"
                                                                                      (replace
                                                                                       -6)
                                                                                      (("1"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (expand
                                                                                       "deriv"
                                                                                       1
                                                                                       2)
                                                                                      (("2"
                                                                                        (propax)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (apply-extensionality
                                                                 1
                                                                 :hide?
                                                                 t)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (lemma
                                                     "not_one_element")
                                                    (("2"
                                                      (propax)
                                                      nil
                                                      nil))
                                                    nil)
                                                   ("3"
                                                    (lemma
                                                     "connected_domain")
                                                    (("3"
                                                      (propax)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (skosimp*) (("2" (assertnil nil))
                            nil)
                           ("3" (skosimp*) (("3" (assertnil nil))
                            nil)
                           ("4" (skosimp*) (("4" (assertnil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (skosimp*) (("2" (assertnil nil)) nil)
                   ("3" (skosimp*) (("3" (assertnil nil)) nil)
                   ("4" (skosimp*) (("4" (assertnil nil)) nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (hide 2)
            (("2" (skosimp*)
              (("2" (typepred "GET_tk(x!1, h!1, k!1)")
                (("2" (name-replace "TK" "GET_tk(x!1, h!1, k!1)")
                  (("2" (grind) nil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((comparison_test_gen formula-decl nil series nil)
    (end_series_conv formula-decl nil series nil)
    (conv_series_scal formula-decl nil series nil)
    (series_scal formula-decl nil series nil)
    (deriv const-decl "[T -> real]" derivatives "analysis/")
    (deriv const-decl "real" derivatives_def "analysis/")
    (deriv_fun type-eq-decl nil derivatives "analysis/")
    (deriv_x_to_n formula-decl nil derivatives "analysis/")
    (mean_value formula-decl nil derivative_props "analysis/")
    (hat_02n formula-decl nil power_series nil)
    (abs_hat formula-decl nil exponent_props "reals/")
    (A const-decl "setof[nzreal]" derivatives_def "analysis/")
    (between type-eq-decl nil taylors "analysis/"))
   nil)
  (Gseq_conv-4 nil 3298994988
   ("" (skosimp*)
    (("" (expand "conv_series?")
      (("" (expand "Gseq")
        ((""
          (case "FORALL (k: above(1)): abs(x!1 - GET_tk(x!1, h!1, k)) < abs(h!1)")
          (("1" (lemma "comparison_test_gen")
            (("1" (name "ALPH" "max(abs(x!1),abs(x!1+h!1))")
              (("1" (lemma "end_series_conv")
                (("1" (inst?)
                  (("1" (assert)
                    (("1" (hide 2)
                      (("1" (assert)
                        (("1"
                          (inst - "(LAMBDA (k):
                                                  IF k < 2 THEN k * a!1(k)
                                                  ELSE k * a!1(k) * GET_tk(x!1, h!1, k) ^ (k - 1) -
                                                        k * a!1(k) * x!1 ^ (k - 1)
                                                  ENDIF)"
                           "(LAMBDA (k): IF k < 2 THEN 0 ELSE abs(h!1*k)*abs(k-1)*abs(a!1(k)*ALPH^(k-2)) ENDIF)")
                          (("1" (assert)
                            (("1" (hide 1)
                              (("1"
                                (split +)
                                (("1"
                                  (hide -1 -2)
                                  (("1"
                                    (case-replace
                                     "(LAMBDA (k):
                           IF k < 2 THEN 0
                           ELSE abs(k - 1) * abs(a!1(k) * ALPH ^ (k - 2)) *
                                 abs(h!1 * k)
                           ENDIF) =
                 (LAMBDA (k): abs(h!1)*
                           IF k < 2 THEN 0
                           ELSE abs(k)*abs(k - 1) * abs(a!1(k)) * abs(ALPH ^ (k - 2))
                                 
                           ENDIF)")
                                    (("1"
                                      (hide -1)
                                      (("1"
                                        (lemma "conv_scaf0")
                                        (("1"
                                          (inst?)
                                          (("1"
                                            (inst - "ALPH")
                                            (("1"
                                              (assert)
                                              (("1"
                                                (lemma
                                                 "convergent_scal")
                                                (("1"
                                                  (inst?)
                                                  (("1"
                                                    (inst - "abs(h!1)")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (rewrite
                                                         "series_scal")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (expand
                                                             "*")
                                                            (("1"
                                                              (propax)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (skosimp*)
                                                          (("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (skosimp*)
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (assert)
                                              (("2"
                                                (reveal -4)
                                                (("2"
                                                  (replace -1 * rl)
                                                  (("2"
                                                    (hide -1 -2 2)
                                                    (("2"
                                                      (typepred "h!1")
                                                      (("2"
                                                        (expand "A")
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (lemma
                                                             "ball")
                                                            (("2"
                                                              (inst
                                                               -
                                                               "(h!1 + x!1)")
                                                              (("2"
                                                                (lemma
                                                                 "ball")
                                                                (("2"
                                                                  (inst
                                                                   -
                                                                   "(x!1)")
                                                                  (("2"
                                                                    (grind)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (hide 2)
                                      (("2"
                                        (apply-extensionality
                                         1
                                         :hide?
                                         t)
                                        (("1"
                                          (lift-if)
                                          (("1"
                                            (rewrite "abs_mult")
                                            (("1"
                                              (rewrite "abs_mult")
                                              (("1" (ground) nil nil))
                                              nil)
                                             ("2"
                                              (flatten)
                                              (("2"
                                                (reveal -2)
                                                (("2"
                                                  (replace -1 * rl)
                                                  (("2"
                                                    (hide-all-but -2)
                                                    (("2"
                                                      (grind)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (skosimp*)
                                          (("2" (assertnil nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("3"
                                      (skosimp*)
                                      (("3" (assertnil nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (inst 1 "3")
                                  (("2"
                                    (skosimp*)
                                    (("2"
                                      (lift-if)
                                      (("2"
                                        (ground)
                                        (("2"
                                          (inst -3 "n!1")
                                          (("2"
                                            (name
                                             "TK"
                                             "GET_tk(x!1, h!1, n!1)")
                                            (("2"
                                              (case
                                               "(EXISTS (PKM1: between[T](x!1,TK)):
                                                                             abs(x!1^(n!1-1) - TK^(n!1-1)) =
                                                                                abs(x!1 - TK)*abs(n!1-1)*abs(PKM1^(n!1-2)))")
                                              (("1"
                                                (skosimp*)
                                                (("1"
                                                  (replace -2)
                                                  (("1"
                                                    (case
                                                     "abs(PKM1!1) <= abs(ALPH)")
                                                    (("1"
                                                      (case
                                                       "abs(a!1(n!1) * TK ^(n!1 - 1) * n!1 -
                                                                    a!1(n!1) * x!1 ^ (n!1 - 1) * n!1) =
                                                                 abs(a!1(n!1))*abs(n!1)*abs(TK ^ (n!1 - 1) - x!1 ^ (n!1 - 1))")
                                                      (("1"
                                                        (replace -1)
                                                        (("1"
                                                          (hide -1)
                                                          (("1"
                                                            (rewrite
                                                             "abs_mult")
                                                            (("1"
                                                              (rewrite
                                                               "abs_mult")
                                                              (("1"
                                                                (auto-rewrite
                                                                 "abs_0")
                                                                (("1"
                                                                  (case-replace
                                                                   "ALPH = 0")
                                                                  (("1"
                                                                    (hide-all-but
                                                                     -6)
                                                                    (("1"
                                                                      (grind)
                                                                      nil
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (div-by
                                                                     3
                                                                     "abs(n!1)*abs(n!1-1)")
                                                                    (("1"
                                                                      (field
                                                                       3)
                                                                      (("1"
                                                                        (lemma
                                                                         "abs_neg")
                                                                        (("1"
                                                                          (inst
                                                                           -
                                                                           "(x!1 ^ (n!1 - 1) - TK ^ (n!1 - 1))")
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (replace
                                                                               -1)
                                                                              (("1"
                                                                                (replace
                                                                                 -5)
                                                                                (("1"
                                                                                  (div-by
                                                                                   3
                                                                                   "abs(n!1-1)")
                                                                                  (("1"
                                                                                    (field
                                                                                     3)
                                                                                    (("1"
                                                                                      (hide
                                                                                       -1
                                                                                       -3-6
                                                                                       -7
                                                                                       -10)
                                                                                      (("1"
                                                                                        (lemma
                                                                                         "both_sides_expt_pos_ge")
                                                                                        (("1"
                                                                                          (inst
                                                                                           -
                                                                                           "(n!1-2)"
                                                                                           "abs(ALPH)"
                                                                                           "abs(PKM1!1)")
                                                                                          (("1"
                                                                                            (assert)
                                                                                            (("1"
                                                                                              (rewrite
                                                                                               "abs_hat"
                                                                                               :dir
                                                                                               rl)
                                                                                              (("1"
                                                                                                (div-by
                                                                                                 3
                                                                                                 "abs(a!1(n!1))")
                                                                                                (("1"
                                                                                                  (field
                                                                                                   3)
                                                                                                  (("1"
                                                                                                    (case-replace
                                                                                                     "PKM1!1 = 0")
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      (("1"
                                                                                                        (rewrite
                                                                                                         "zero_hat")
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (lemma
                                                                                                       "abs_eq_0")
                                                                                                      (("2"
                                                                                                        (inst
                                                                                                         -
                                                                                                         "PKM1!1")
                                                                                                        (("2"
                                                                                                          (assert)
                                                                                                          (("2"
                                                                                                            (rewrite
                                                                                                             "abs_hat"
                                                                                                             :dir
                                                                                                             rl)
                                                                                                            (("2"
                                                                                                              (div-by
                                                                                                               5
                                                                                                               "abs(a!1(n!1))")
                                                                                                              (("2"
                                                                                                                (field
                                                                                                                 5)
                                                                                                                (("2"
                                                                                                                  (mult-ineq
                                                                                                                   -3
                                                                                                                   -10)
                                                                                                                  (("1"
                                                                                                                    (assert)
                                                                                                                    nil
                                                                                                                    nil)
                                                                                                                   ("2"
                                                                                                                    (auto-rewrite
                                                                                                                     "abs_abs")
                                                                                                                    (("2"
                                                                                                                      (assert)
                                                                                                                      nil
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (lemma
                                                                                             "abs_eq_0")
                                                                                            (("2"
                                                                                              (inst
                                                                                               -
                                                                                               "PKM1!1")
                                                                                              (("2"
                                                                                                (assert)
                                                                                                (("2"
                                                                                                  (replace
                                                                                                   -1)
                                                                                                  (("2"
                                                                                                    (assert)
                                                                                                    (("2"
                                                                                                      (rewrite
                                                                                                       "zero_hat")
                                                                                                      (("2"
                                                                                                        (assert)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (assert)
                                                                      (("2"
                                                                        (hide-all-but
                                                                         (1
                                                                          3))
                                                                        (("2"
                                                                          (mult-cases
                                                                           1)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (hide 3)
                                                        (("2"
                                                          (hide-all-but
                                                           1)
                                                          (("2"
                                                            (case-replace
                                                             "a!1(n!1) * TK ^ (n!1 - 1) * n!1 -
                                                           a!1(n!1) * x!1 ^ (n!1 - 1) * n!1 =
                                                           a!1(n!1) * n!1*(TK ^(n!1 - 1) - x!1^(n!1 - 1))")
                                                            (("1"
                                                              (rewrite
                                                               "abs_mult")
                                                              (("1"
                                                                (rewrite
                                                                 "abs_mult")
                                                                nil
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (hide 2)
                                                              (("2"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (hide 3)
                                                      (("2"
                                                        (replace
                                                         -4
                                                         *
                                                         rl)
                                                        (("2"
                                                          (hide -4)
                                                          (("2"
                                                            (hide
                                                             -1
                                                             -2)
                                                            (("2"
                                                              (hide -3)
                                                              (("2"
                                                                (case-replace
                                                                 "abs(max(abs(x!1), abs(h!1 + x!1))) = (max(abs(x!1), abs(h!1 + x!1)))")
                                                                (("1"
                                                                  (hide
                                                                   -1)
                                                                  (("1"
                                                                    (hide
                                                                     -2)
                                                                    (("1"
                                                                      (typepred
                                                                       "TK")
                                                                      (("1"
                                                                        (hide
                                                                         -5)
                                                                        (("1"
                                                                          (typepred
                                                                           "PKM1!1")
                                                                          (("1"
                                                                            (grind)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (hide
                                                                   2)
                                                                  (("2"
                                                                    (grind)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (hide 3)
                                                (("2"
                                                  (lemma
                                                   "mean_value[T]")
                                                  (("1"
                                                    (inst
                                                     -
                                                     "TK"
                                                     "x!1"
                                                     "(LAMBDA (x:T): x^(n!1-1))")
                                                    (("1"
                                                      (lemma
                                                       "deriv_x_to_n[T]")
                                                      (("1"
                                                        (inst
                                                         -
                                                         "(n!1-1)"
                                                         "1")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (flatten)
                                                            (("1"
                                                              (case-replace
                                                               "(LAMBDA (x: T): 1 * x ^ (n!1 - 1)) = (LAMBDA (x: T): x ^ (n!1 - 1))")
                                                              (("1"
                                                                (hide
                                                                 -1)
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (split
                                                                     -3)
                                                                    (("1"
                                                                      (skosimp*)
                                                                      (("1"
                                                                        (inst
                                                                         +
                                                                         "c!1")
                                                                        (("1"
                                                                          (case-replace
                                                                           "deriv((LAMBDA (x: T): x ^ (n!1 - 1)), c!1) =
                                         (n!1-1)*c!1^(n!1-2)")
                                                                          (("1"
                                                                            (factor
                                                                             -4
                                                                             l)
                                                                            (("1"
                                                                              (hide-all-but
                                                                               (-4
                                                                                1))
                                                                              (("1"
                                                                                (name-replace
                                                                                 "NM1"
                                                                                 "n!1-1")
                                                                                (("1"
                                                                                  (replace
                                                                                   -1
                                                                                   *
                                                                                   rl)
                                                                                  (("1"
                                                                                    (rewrite
                                                                                     "abs_mult")
                                                                                    (("1"
                                                                                      (rewrite
                                                                                       "abs_mult")
                                                                                      (("1"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (hide
                                                                             2)
                                                                            (("2"
                                                                              (lemma
                                                                               "deriv_x_to_n[T]")
                                                                              (("2"
                                                                                (assert)
                                                                                (("2"
                                                                                  (inst
                                                                                   -
                                                                                   "(n!1-1)"
                                                                                   "1")
                                                                                  (("2"
                                                                                    (flatten)
                                                                                    (("2"
                                                                                      (case-replace
                                                                                       "(LAMBDA (x: T): 1 * x ^ (n!1 - 1)) = (LAMBDA (x: T): x ^ (n!1 - 1))")
                                                                                      (("1"
                                                                                        (hide
                                                                                         -1)
                                                                                        (("1"
                                                                                          (replace
                                                                                           -2)
                                                                                          (("1"
                                                                                            (hide-all-but
                                                                                             (-1
                                                                                              -2
                                                                                              1))
                                                                                            (("1"
                                                                                              (assert)
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "deriv"
                                                                                                 -2)
                                                                                                (("1"
                                                                                                  (assert)
                                                                                                  (("1"
                                                                                                    (case-replace
                                                                                                     "(LAMBDA (x_1: T): deriv((LAMBDA (x: T): x ^ (n!1 - 1)), x_1))(c!1)
 =
       (LAMBDA (x: T): (x ^ (n!1 - 2)) * n!1 - x ^ (n!1 - 2))(c!1)")
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      nil
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (hide
                                                                                                       2)
                                                                                                      (("2"
                                                                                                        (replace
                                                                                                         -2)
                                                                                                        (("2"
                                                                                                          (propax)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("3"
                                                                                                      (lemma
                                                                                                       "not_one_element")
                                                                                                      (("3"
                                                                                                        (propax)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("4"
                                                                                                      (lemma
                                                                                                       "connected_domain")
                                                                                                      (("4"
                                                                                                        (propax)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("5"
                                                                                                      (hide
                                                                                                       -2
                                                                                                       2)
                                                                                                      (("5"
                                                                                                        (expand
                                                                                                         "derivable"
                                                                                                         -1)
                                                                                                        (("5"
                                                                                                          (inst?)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (apply-extensionality
                                                                                         1
                                                                                         :hide?
                                                                                         t)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("3"
                                                                            (hide-all-but
                                                                             (-4
                                                                              1))
                                                                            (("3"
                                                                              (expand
                                                                               "derivable"
                                                                               -1)
                                                                              (("3"
                                                                                (inst?)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (ground)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (case-replace
                                                                       "x!1 = TK")
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (rewrite
                                                                           "abs_0")
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (typepred
                                                                               "TK")
                                                                              (("1"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (lemma
                                                                         "mean_value[T]")
                                                                        (("2"
                                                                          (inst
                                                                           -
                                                                           "x!1"
                                                                           "TK"
                                                                           "(LAMBDA (x:T): x^(n!1-1))")
                                                                          (("2"
                                                                            (assert)
                                                                            (("2"
                                                                              (skosimp*)
                                                                              (("2"
                                                                                (inst
                                                                                 +
                                                                                 "c!1")
                                                                                (("1"
                                                                                  (case-replace
                                                                                   "deriv((LAMBDA (x: T): x ^ (n!1 - 1)), c!1) =
                                                             (n!1-1)*c!1^(n!1-2)")
                                                                                  (("1"
                                                                                    (factor
                                                                                     -4
                                                                                     l)
                                                                                    (("1"
                                                                                      (hide-all-but
                                                                                       (-4
                                                                                        1
                                                                                        2
                                                                                        3))
                                                                                      (("1"
                                                                                        (name-replace
                                                                                         "NM1"
                                                                                         "n!1-1")
                                                                                        (("1"
                                                                                          (lemma
                                                                                           "abs_neg")
                                                                                          (("1"
                                                                                            (inst
                                                                                             -
                                                                                             "(x!1 - TK)")
                                                                                            (("1"
                                                                                              (replace
                                                                                               -1
                                                                                               *
                                                                                               rl)
                                                                                              (("1"
                                                                                                (name-replace
                                                                                                 "TKMx"
                                                                                                 "(TK - x!1)")
                                                                                                (("1"
                                                                                                  (hide
                                                                                                   -1)
                                                                                                  (("1"
                                                                                                    (case-replace
                                                                                                     "abs(x!1 ^ NM1 - TK ^ NM1) = abs(TK ^ NM1 - x!1 ^ NM1) ")
                                                                                                    (("1"
                                                                                                      (replace
                                                                                                       -2
                                                                                                       *
                                                                                                       rl)
                                                                                                      (("1"
                                                                                                        (hide
                                                                                                         -1
                                                                                                         -2)
                                                                                                        (("1"
                                                                                                          (rewrite
                                                                                                           "abs_mult")
                                                                                                          (("1"
                                                                                                            (rewrite
                                                                                                             "abs_mult")
                                                                                                            (("1"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (hide-all-but
                                                                                                       1)
                                                                                                      (("2"
                                                                                                        (expand
                                                                                                         "abs")
                                                                                                        (("2"
                                                                                                          (lift-if)
                                                                                                          (("2"
                                                                                                            (lift-if)
                                                                                                            (("2"
                                                                                                              (ground)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("3"
                                                                                                      (assert)
                                                                                                      (("3"
                                                                                                        (reveal
                                                                                                         -4)
                                                                                                        (("3"
                                                                                                          (replace
                                                                                                           -1
                                                                                                           *
                                                                                                           rl)
                                                                                                          (("3"
                                                                                                            (assert)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("4"
                                                                                                      (reveal
                                                                                                       -4)
                                                                                                      (("4"
                                                                                                        (replace
                                                                                                         -1
                                                                                                         *
                                                                                                         rl)
                                                                                                        (("4"
                                                                                                          (assert)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil)
                                                                                   ("2"
                                                                                    (case-replace
                                                                                     "deriv((LAMBDA (x: T): x ^ (n!1 - 1)), c!1) = deriv(LAMBDA (x: T): x ^ (n!1 - 1))(c!1)")
                                                                                    (("1"
                                                                                      (replace
                                                                                       -6)
                                                                                      (("1"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (expand
                                                                                       "deriv"
                                                                                       1
                                                                                       2)
                                                                                      (("2"
                                                                                        (propax)
                                                                                        nil
                                                                                        nil))
                                                                                      nil)
                                                                                     ("3"
                                                                                      (expand
                                                                                       "derivable"
                                                                                       -4)
                                                                                      (("3"
                                                                                        (inst?)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil)
                                                                                   ("3"
                                                                                    (expand
                                                                                     "derivable"
                                                                                     -4)
                                                                                    (("3"
                                                                                      (inst?)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (apply-extensionality
                                                                 1
                                                                 :hide?
                                                                 t)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (lemma
                                                     "not_one_element")
                                                    (("2"
                                                      (propax)
                                                      nil
                                                      nil))
                                                    nil)
                                                   ("3"
                                                    (lemma
                                                     "connected_domain")
                                                    (("3"
                                                      (propax)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (skosimp*) (("2" (assertnil nil))
                            nil)
                           ("3" (skosimp*) (("3" (assertnil nil))
                            nil)
                           ("4" (skosimp*) (("4" (assertnil nil))
                            nil)
                           ("5" (skosimp*) (("5" (assertnil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (skosimp*) (("2" (assertnil nil)) nil)
                   ("3" (skosimp*) (("3" (assertnil nil)) nil)
                   ("4" (skosimp*) (("4" (assertnil nil)) nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (hide 2)
            (("2" (skosimp*)
              (("2" (typepred "GET_tk(x!1, h!1, k!1)")
                (("2" (name-replace "TK" "GET_tk(x!1, h!1, k!1)")
                  (("2" (grind) nil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((between type-eq-decl nil taylors "analysis/")
    (abs_hat formula-decl nil exponent_props "reals/")
    (zero_hat formula-decl nil exponent_props "reals/")
    (mean_value formula-decl nil derivative_props "analysis/")
    (deriv_x_to_n formula-decl nil derivatives "analysis/")
    (deriv_fun type-eq-decl nil derivatives "analysis/")
    (deriv const-decl "[T -> real]" derivatives "analysis/")
    (deriv const-decl "[T -> real]" derivatives "analysis/")
    (series_scal formula-decl nil series nil)
    (convergent_scal formula-decl nil convergence_ops "analysis/")
    (end_series_conv formula-decl nil series nil)
    (comparison_test_gen formula-decl nil series nil))
   nil)
  (Gseq_conv-3 nil 3298987688
   ("" (skosimp*)
    (("" (expand "conv_series?")
      (("" (expand "Gseq")
        ((""
          (case "FORALL (k: above(1)): abs(x!1 - GET_tk(x!1, h!1, k)) < abs(h!1)")
          (("1" (lemma "comparison_test_gen")
            (("1" (name "ALPH" "max(abs(x!1),abs(x!1+h!1))")
              (("1" (lemma "end_series_conv")
                (("1" (inst?)
                  (("1" (assert)
                    (("1" (hide 2)
                      (("1" (assert)
                        (("1"
                          (inst - "(LAMBDA (k):
                                            IF k < 2 THEN k * a!1(k)
                                            ELSE k * a!1(k) * GET_tk(x!1, h!1, k) ^ (k - 1) -
                                                  k * a!1(k) * x!1 ^ (k - 1)
                                            ENDIF)"
                           "(LAMBDA (k): IF k < 2 THEN 0 ELSE abs(h!1*k)*abs(k-1)*abs(a!1(k)*ALPH^(k-2)) ENDIF)")
                          (("1" (assert)
                            (("1" (hide 1)
                              (("1"
                                (split +)
                                (("1" (postpone) nil nil)
                                 ("2"
                                  (inst 1 "3")
                                  (("2"
                                    (skosimp*)
                                    (("2"
                                      (lift-if)
                                      (("2"
                                        (ground)
                                        (("2"
                                          (inst -3 "n!1")
                                          (("2"
                                            (name
                                             "TK"
                                             "GET_tk(x!1, h!1, n!1)")
                                            (("2"
                                              (case
                                               "(EXISTS (PKM1: between[T](x!1,TK)):
                                                              abs(x!1^(n!1-1) - TK^(n!1-1)) =
                                                                 abs(x!1 - TK)*abs(n!1-1)*abs(PKM1^(n!1-2)))")
                                              (("1"
                                                (skosimp*)
                                                (("1"
                                                  (replace -2)
                                                  (("1"
                                                    (case
                                                     "abs(PKM1!1) <= abs(ALPH)")
                                                    (("1"
                                                      (case
                                                       "abs(a!1(n!1) * TK ^(n!1 - 1) * n!1 -
                                                 a!1(n!1) * x!1 ^ (n!1 - 1) * n!1) =
                                              abs(a!1(n!1))*abs(n!1)*abs(TK ^ (n!1 - 1) - x!1 ^ (n!1 - 1))")
                                                      (("1"
                                                        (replace -1)
                                                        (("1"
                                                          (hide -1)
                                                          (("1"
                                                            (rewrite
                                                             "abs_mult")
                                                            (("1"
                                                              (rewrite
                                                               "abs_mult")
                                                              (("1"
                                                                (auto-rewrite
                                                                 "abs_0")
                                                                (("1"
                                                                  (case-replace
                                                                   "ALPH = 0")
                                                                  (("1"
                                                                    (hide-all-but
                                                                     -6)
                                                                    (("1"
                                                                      (grind)
                                                                      nil
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (div-by
                                                                     3
                                                                     "abs(n!1)*abs(n!1-1)")
                                                                    (("1"
                                                                      (field
                                                                       3)
                                                                      (("1"
                                                                        (lemma
                                                                         "abs_neg")
                                                                        (("1"
                                                                          (inst
                                                                           -
                                                                           "(x!1 ^ (n!1 - 1) - TK ^ (n!1 - 1))")
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (replace
                                                                               -1)
                                                                              (("1"
                                                                                (replace
                                                                                 -5)
                                                                                (("1"
                                                                                  (div-by
                                                                                   3
                                                                                   "abs(n!1-1)")
                                                                                  (("1"
                                                                                    (field
                                                                                     3)
                                                                                    (("1"
                                                                                      (hide
                                                                                       -1
                                                                                       -3-6
                                                                                       -7
                                                                                       -10)
                                                                                      (("1"
                                                                                        (lemma
                                                                                         "both_sides_expt_pos_ge")
                                                                                        (("1"
                                                                                          (inst
                                                                                           -
                                                                                           "(n!1-2)"
                                                                                           "abs(ALPH)"
                                                                                           "abs(PKM1!1)")
                                                                                          (("1"
                                                                                            (assert)
                                                                                            (("1"
                                                                                              (rewrite
                                                                                               "abs_hat"
                                                                                               :dir
                                                                                               rl)
                                                                                              (("1"
                                                                                                (div-by
                                                                                                 3
                                                                                                 "abs(a!1(n!1))")
                                                                                                (("1"
                                                                                                  (field
                                                                                                   3)
                                                                                                  (("1"
                                                                                                    (case-replace
                                                                                                     "PKM1!1 = 0")
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      (("1"
                                                                                                        (rewrite
                                                                                                         "zero_hat")
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (lemma
                                                                                                       "abs_eq_0")
                                                                                                      (("2"
                                                                                                        (inst
                                                                                                         -
                                                                                                         "PKM1!1")
                                                                                                        (("2"
                                                                                                          (assert)
                                                                                                          (("2"
                                                                                                            (rewrite
                                                                                                             "abs_hat"
                                                                                                             :dir
                                                                                                             rl)
                                                                                                            (("2"
                                                                                                              (div-by
                                                                                                               5
                                                                                                               "abs(a!1(n!1))")
                                                                                                              (("2"
                                                                                                                (field
                                                                                                                 5)
                                                                                                                (("2"
                                                                                                                  (mult-ineq
                                                                                                                   -3
                                                                                                                   -10)
                                                                                                                  (("1"
                                                                                                                    (assert)
                                                                                                                    nil
                                                                                                                    nil)
                                                                                                                   ("2"
                                                                                                                    (auto-rewrite
                                                                                                                     "abs_abs")
                                                                                                                    (("2"
                                                                                                                      (assert)
                                                                                                                      nil
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (lemma
                                                                                             "abs_eq_0")
                                                                                            (("2"
                                                                                              (inst
                                                                                               -
                                                                                               "PKM1!1")
                                                                                              (("2"
                                                                                                (assert)
                                                                                                (("2"
                                                                                                  (replace
                                                                                                   -1)
                                                                                                  (("2"
                                                                                                    (assert)
                                                                                                    (("2"
                                                                                                      (rewrite
                                                                                                       "zero_hat")
                                                                                                      (("2"
                                                                                                        (assert)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (assert)
                                                                      (("2"
                                                                        (hide-all-but
                                                                         (1
                                                                          3))
                                                                        (("2"
                                                                          (mult-cases
                                                                           1)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (hide 3)
                                                        (("2"
                                                          (hide-all-but
                                                           1)
                                                          (("2"
                                                            (case-replace
                                                             "a!1(n!1) * TK ^ (n!1 - 1) * n!1 -
                                           a!1(n!1) * x!1 ^ (n!1 - 1) * n!1 =
                                           a!1(n!1) * n!1*(TK ^(n!1 - 1) - x!1^(n!1 - 1))")
                                                            (("1"
                                                              (rewrite
                                                               "abs_mult")
                                                              (("1"
                                                                (rewrite
                                                                 "abs_mult")
                                                                nil
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (hide 2)
                                                              (("2"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (hide 3)
                                                      (("2"
                                                        (replace
                                                         -4
                                                         *
                                                         rl)
                                                        (("2"
                                                          (hide -4)
                                                          (("2"
                                                            (hide
                                                             -1
                                                             -2)
                                                            (("2"
                                                              (hide -3)
                                                              (("2"
                                                                (case-replace
                                                                 "abs(max(abs(x!1), abs(h!1 + x!1))) = (max(abs(x!1), abs(h!1 + x!1)))")
                                                                (("1"
                                                                  (hide
                                                                   -1)
                                                                  (("1"
                                                                    (hide
                                                                     -2)
                                                                    (("1"
                                                                      (typepred
                                                                       "TK")
                                                                      (("1"
                                                                        (hide
                                                                         -5)
                                                                        (("1"
                                                                          (typepred
                                                                           "PKM1!1")
                                                                          (("1"
                                                                            (grind)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (hide
                                                                   2)
                                                                  (("2"
                                                                    (grind)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (hide 3)
                                                (("2"
                                                  (lemma
                                                   "mean_value[T]")
                                                  (("1"
                                                    (inst
                                                     -
                                                     "x!1"
                                                     "TK"
                                                     "(LAMBDA (x:T): x^(n!1-1))")
                                                    (("1"
                                                      (lemma
                                                       "deriv_x_to_n[T]")
                                                      (("1"
                                                        (inst
                                                         -
                                                         "(n!1-1)"
                                                         "1")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (flatten)
                                                            (("1"
                                                              (case-replace
                                                               "(LAMBDA (x: T): 1 * x ^ (n!1 - 1)) = (LAMBDA (x: T): x ^ (n!1 - 1))")
                                                              (("1"
                                                                (hide
                                                                 -1)
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (split
                                                                     -3)
                                                                    (("1"
                                                                      (skosimp*)
                                                                      (("1"
                                                                        (inst
                                                                         +
                                                                         "c!1")
                                                                        (("1"
                                                                          (case-replace
                                                                           "deriv((LAMBDA (x: T): x ^ (n!1 - 1)), c!1) =
                     (n!1-1)*c!1^(n!1-2)")
                                                                          (("1"
                                                                            (lemma
                                                                             "abs_neg")
                                                                            (("1"
                                                                              (inst
                                                                               -1
                                                                               "x!1 ^ (n!1 - 1) - TK ^ (n!1 - 1)")
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (replace
                                                                                   -1
                                                                                   +
                                                                                   rl)
                                                                                  (("1"
                                                                                    (postpone)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (postpone)
                                                                            nil
                                                                            nil)
                                                                           ("3"
                                                                            (postpone)
                                                                            nil
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (postpone)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (postpone)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (postpone)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (postpone)
                                                    nil
                                                    nil)
                                                   ("3"
                                                    (postpone)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (skosimp*) (("2" (assertnil nil))
                            nil)
                           ("3" (skosimp*) (("3" (assertnil nil))
                            nil)
                           ("4" (skosimp*) (("4" (assertnil nil))
                            nil)
                           ("5" (skosimp*) (("5" (assertnil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (skosimp*) (("2" (assertnil nil)) nil)
                   ("3" (skosimp*) (("3" (assertnil nil)) nil)
                   ("4" (skosimp*) (("4" (assertnil nil)) nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (hide 2)
            (("2" (skosimp*)
              (("2" (typepred "GET_tk(x!1, h!1, k!1)")
                (("2" (name-replace "TK" "GET_tk(x!1, h!1, k!1)")
                  (("2" (grind) nil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   nil nil)
  (Gseq_conv-2 nil 3298986947
   ("" (skosimp*)
    (("" (expand "conv_series?")
      (("" (expand "Gseq")
        ((""
          (case "FORALL (k: above(1)): abs(x!1 - GET_tk(x!1, h!1, k)) < abs(h!1)")
          (("1" (lemma "comparison_test_gen")
            (("1" (name "ALPH" "max(abs(x!1),abs(x!1+h!1))")
              (("1" (lemma "end_series_conv")
                (("1" (inst?)
                  (("1" (assert)
                    (("1" (hide 2)
                      (("1"
                        (inst - "(LAMBDA (k):
                                IF k < 2 THEN k * a!1(k)
                                ELSE k * a!1(k) * GET_tk(x!1, h!1, k) ^ (k - 1) -
                                      k * a!1(k) * x!1 ^ (k - 1)
                                ENDIF)"
                         "(LAMBDA (k): abs(h!1*k)*abs(k-1)*abs(a!1(k)*ALPH^k-2))")
                        (("1" (assert)
                          (("1" (hide 1)
                            (("1" (split +)
                              (("1" (postpone) nil nil)
                               ("2"
                                (inst 1 "2")
                                (("2"
                                  (skosimp*)
                                  (("2"
                                    (lift-if)
                                    (("2"
                                      (ground)
                                      (("2"
                                        (inst -3 "n!1")
                                        (("2"
                                          (name
                                           "TK"
                                           "GET_tk(x!1, h!1, n!1)")
                                          (("2"
                                            (case
                                             "(EXISTS (PKM1: between[T](x!1,TK)):
                                abs(x!1^(n!1-1) - TK^(n!1-1)) =
                                   abs(x!1 - TK)*abs(n!1-1)*abs(PKM1^(n!1-2)))")
                                            (("1"
                                              (skosimp*)
                                              (("1"
                                                (replace -2)
                                                (("1"
                                                  (case
                                                   "abs(PKM1!1) <= abs(ALPH)")
                                                  (("1"
                                                    (case
                                                     "abs(a!1(n!1) * TK ^ (n!1 - 1) * n!1 -
           a!1(n!1) * x!1 ^ (n!1 - 1) * n!1) =
        abs(a!1(n!1))*abs(n!1)*abs(TK ^ (n!1 - 1) - x!1 ^ (n!1 - 1))")
                                                    (("1"
                                                      (replace -1)
                                                      (("1"
                                                        (hide -1)
                                                        (("1"
                                                          (rewrite
                                                           "abs_mult")
                                                          (("1"
                                                            (postpone)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (hide-all-but 1)
                                                      (("2"
                                                        (case-replace
                                                         "a!1(n!1) * TK ^ (n!1 - 1) * n!1 -
           a!1(n!1) * x!1 ^ (n!1 - 1) * n!1 =
           a!1(n!1) * n!1*(TK ^ (n!1 - 1) - x!1 ^ (n!1 - 1))")
                                                        (("1"
                                                          (rewrite
                                                           "abs_mult")
                                                          (("1"
                                                            (rewrite
                                                             "abs_mult")
                                                            nil
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (hide 2)
                                                          (("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (postpone)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2" (postpone) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (skosimp*) (("2" (assertnil nil)) nil)
                         ("3" (skosimp*) (("3" (assertnil nil)) nil)
                         ("4" (skosimp*) (("4" (assertnil nil)) nil))
                        nil))
                      nil))
                    nil)
                   ("2" (skosimp*) (("2" (assertnil nil)) nil)
                   ("3" (skosimp*) (("3" (assertnil nil)) nil)
                   ("4" (skosimp*) (("4" (assertnil nil)) nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (hide 2)
            (("2" (skosimp*)
              (("2" (typepred "GET_tk(x!1, h!1, k!1)")
                (("2" (name-replace "TK" "GET_tk(x!1, h!1, k!1)")
                  (("2" (grind) nil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   nil nil)
  (Gseq_conv-1 nil 3298804872
   ("" (skosimp*)
    (("" (expand "conv_series?")
      (("" (expand "Gseq")
        ((""
          (case "FORALL (k: above(1)): abs(x!1 - GET_tk(x!1, h!1, k)) < abs(h!1)")
          (("1" (lemma "comparison_test_gen")
            (("1" (name "ALPH" "max(abs(x!1),abs(x!1+h!1))")
              (("1" (lemma "end_series_conv")
                (("1" (inst?)
                  (("1" (assert)
                    (("1" (hide 2)
                      (("1"
                        (inst - "(LAMBDA (k):
                          IF k < 2 THEN k * a!1(k)
                          ELSE k * a!1(k) * GET_tk(x!1, h!1, k) ^ (k - 1) -
                                k * a!1(k) * x!1 ^ (k - 1)
                          ENDIF)"
                         "(LAMBDA (k): abs(h!1*k*(k-1))*abs(a!1(k)*ALPH^k-2))")
                        (("1" (assert)
                          (("1" (hide 1)
                            (("1" (split +)
                              (("1" (postpone) nil nil)
                               ("2"
                                (inst 1 "2")
                                (("2"
                                  (skosimp*)
                                  (("2"
                                    (lift-if)
                                    (("2"
                                      (ground)
                                      (("2"
                                        (inst -3 "n!1")
                                        (("2"
                                          (name
                                           "TK"
                                           "GET_tk(x!1, h!1, n!1)")
                                          (("2"
                                            (case
                                             "(EXISTS (PKM1: between[T](x!1,TK)):
                 abs(x!1^(n!1-1) - TK^(n!1-1)) =
                    abs(x!1 - TK)*abs(n!1-1)*abs(PKM1^(n!1-2)))")
                                            (("1"
                                              (skosimp*)
                                              (("1"
                                                (replace -2)
                                                (("1"
                                                  (case
                                                   "abs(PKM1!1) <= abs(ALPH)")
                                                  (("1"
                                                    (postpone)
                                                    nil
                                                    nil)
                                                   ("2"
                                                    (postpone)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2" (postpone) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (skosimp*) (("2" (assertnil nil)) nil)
                         ("3" (skosimp*) (("3" (assertnil nil)) nil)
                         ("4" (skosimp*) (("4" (assertnil nil)) nil))
                        nil))
                      nil))
                    nil)
                   ("2" (skosimp*) (("2" (assertnil nil)) nil)
                   ("3" (skosimp*) (("3" (assertnil nil)) nil)
                   ("4" (skosimp*) (("4" (assertnil nil)) nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (hide 2)
            (("2" (skosimp*)
              (("2" (typepred "GET_tk(x!1, h!1, k!1)")
                (("2" (name-replace "TK" "GET_tk(x!1, h!1, k!1)")
                  (("2" (grind) nil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   nil shostak))
 (abs_Gseq_conv 0
  (abs_Gseq_conv-5 nil 3471698183
   ("" (skosimp*)
    (("" (expand "conv_series?")
      (("" (expand "Gseq")
        ((""
          (case "FORALL (k: above(1)): abs(x!1 - GET_tk(x!1, h!1, k)) < abs(h!1)")
          (("1" (lemma "comparison_test_gen")
            (("1" (name "ALPH" "max(abs(x!1),abs(x!1+h!1))")
              (("1" (lemma "end_series_conv")
                (("1" (inst?)
                  (("1" (assert)
                    (("1" (hide 2)
                      (("1" (assert)
                        (("1"
                          (inst - "abs(LAMBDA (k):
                                                                          IF k < 2 THEN k * a!1(k)
                                                                          ELSE k * a!1(k) * GET_tk(x!1, h!1, k) ^ (k - 1) -
                                                                                k * a!1(k) * x!1 ^ (k - 1)
                                                                          ENDIF)"
                           "(LAMBDA (k): IF k < 2 THEN 0 ELSE abs(h!1*k)*abs(k-1)*abs(a!1(k)*ALPH^(k-2)) ENDIF)")
                          (("1" (assert)
                            (("1" (hide 1)
                              (("1"
                                (split +)
                                (("1"
                                  (hide -1 -2)
                                  (("1"
                                    (case-replace
                                     "(LAMBDA (k):
                                                                   IF k < 2 THEN 0
                                                                   ELSE abs(k - 1) * abs(a!1(k) * ALPH ^ (k - 2)) *
                                                                         abs(h!1 * k)
                                                                   ENDIF) =
                                                         (LAMBDA (k): abs(h!1)*
                                                                   IF k < 2 THEN 0
                                                                   ELSE abs(k)*abs(k - 1) * abs(a!1(k)) * abs(ALPH ^ (k - 2))
                                                                   ENDIF)")
                                    (("1"
                                      (hide -1)
                                      (("1"
                                        (lemma "conv_scaf0")
                                        (("1"
                                          (inst?)
                                          (("1"
                                            (inst - "ALPH")
                                            (("1"
                                              (assert)
                                              (("1"
                                                (lemma
                                                 "conv_series_scal")
                                                (("1"
                                                  (inst?)
                                                  (("1"
                                                    (inst - "abs(h!1)")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (rewrite
                                                         "series_scal")
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (assert)
                                              (("2"
                                                (reveal -4)
                                                (("2"
                                                  (replace -1 * rl)
                                                  (("2"
                                                    (hide -1 -2 2)
                                                    (("2"
                                                      (typepred "h!1")
                                                      (("2"
                                                        (expand "A")
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (lemma
                                                             "ball")
                                                            (("2"
                                                              (inst
                                                               -
                                                               "(h!1 + x!1)")
                                                              (("2"
                                                                (lemma
                                                                 "ball")
                                                                (("2"
                                                                  (inst
                                                                   -
                                                                   "(x!1)")
                                                                  (("2"
                                                                    (grind)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (hide 2)
                                      (("2"
                                        (apply-extensionality
                                         1
                                         :hide?
                                         t)
                                        (("2"
                                          (lift-if)
                                          (("2"
                                            (rewrite "abs_mult")
                                            (("2"
                                              (rewrite "abs_mult")
                                              (("2" (ground) nil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (inst 1 "3")
                                  (("2"
                                    (skosimp*)
                                    (("2"
                                      (lift-if)
                                      (("2"
                                        (ground)
                                        (("2"
                                          (inst -3 "n!1")
                                          (("2"
                                            (expand "abs" 2 2)
                                            (("2"
                                              (rewrite "abs_abs")
                                              (("2"
                                                (name
                                                 "TK"
                                                 "GET_tk(x!1, h!1, n!1)")
--> --------------------

--> maximum size reached

--> --------------------

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

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

*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.