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


Quelle  series_aux.prf

  Sprache: Lisp
 

(series_aux
 (zero_tail_series_conv 0
  (zero_tail_series_conv-1 nil 3314015810
   ("" (skosimp*)
    (("" (lemma "partial_sums" ("a" "a!1"))
      (("" (replace -1 1)
        (("" (hide -1)
          (("" (skosimp)
            (("" (inst + "n!1+1")
              (("" (skosimp)
                ((""
                  (lemma "sigma_eq"
                   ("low" "m!1+1" "high" "n!2" "F" "a!1" "G"
                    "lambda (n:nat): 0"))
                  (("" (rewrite "sigma_zero")
                    (("" (split -1)
                      (("1" (replace -1)
                        (("1" (expand "abs") (("1" (assertnil nil))
                          nil))
                        nil)
                       ("2" (hide 2)
                        (("2" (skosimp*)
                          (("2" (typepred "n!3")
                            (("2" (inst - "n!3")
                              (("2" (assertnil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    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)
    (partial_sums formula-decl nil series nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posint nonempty-type-eq-decl nil integers nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (T_low type-eq-decl nil sigma "reals/")
    (T_high type-eq-decl nil sigma "reals/")
    (<= const-decl "bool" reals nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (sigma_eq formula-decl nil sigma "reals/")
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (real_gt_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_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (subrange type-eq-decl nil integers nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (sigma_zero formula-decl nil sigma "reals/"))
   shostak))
 (zero_tail_series_limit_TCC1 0
  (zero_tail_series_limit_TCC1-1 nil 3314015766
   ("" (lemma "zero_tail_series_conv") (("" (propax) nil nil)) nil)
   ((zero_tail_series_conv formula-decl nil series_aux nil)) shostak))
 (zero_tail_series_limit 0
  (zero_tail_series_limit-1 nil 3314016598
   ("" (skosimp)
    (("" (lemma "zero_tail_series_conv" ("a" "a!1" "n" "n!1"))
      (("" (replace -2 -1)
        (("" (expand "series" 1 2)
          (("" (lemma "limit_series_shift" ("a" "a!1" "pn" "n!1+1"))
            (("" (replace -2 -1)
              (("" (replace -1 1)
                (("" (assert)
                  (("" (hide -1)
                    ((""
                      (case-replace
                       "(LAMBDA (n:nat): a!1(1 + n + n!1)) = (LAMBDA (n:nat): 0)")
                      (("1" (rewrite "zero_series_limit"nil nil)
                       ("2" (hide 2)
                        (("2" (apply-extensionality :hide? t)
                          (("2" (inst - "1+n!1+x!1")
                            (("2" (assertnil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    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)
    (zero_tail_series_conv formula-decl nil series_aux nil)
    (series const-decl "sequence[real]" series nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (zero_series_limit formula-decl nil series nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (limit_series_shift formula-decl nil series nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields
       nil))
   shostak))
 (zero_tail_series 0
  (zero_tail_series-1 nil 3321845471
   ("" (skosimp)
    (("" (lemma "zero_tail_series_conv" ("a" "a!1" "n" "n!1"))
      (("" (lemma "zero_tail_series_limit" ("a" "a!1" "n" "n!1"))
        (("" (replace -3 (-1 -2))
          (("" (rewrite "limit_equiv") (("" (assertnil nil)) nil))
          nil))
        nil))
      nil))
    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)
    (zero_tail_series_conv formula-decl nil series_aux nil)
    (series const-decl "sequence[real]" series nil)
    (limit_equiv formula-decl nil convergence_ops "analysis/")
    (zero_tail_series_limit formula-decl nil series_aux nil))
   shostak))
 (single_nz_series_conv 0
  (single_nz_series_conv-1 nil 3314567201
   ("" (skosimp)
    (("" (lemma "zero_tail_series_conv" ("a" "a!1" "n" "n!1"))
      (("" (split)
        (("1" (propax) nil nil)
         ("2" (skosimp)
          (("2" (inst - "m!1") (("2" (assertnil nil)) nil)) nil))
        nil))
      nil))
    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)
    (zero_tail_series_conv formula-decl nil series_aux nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   shostak))
 (single_nz_series_limit_TCC1 0
  (single_nz_series_limit_TCC1-1 nil 3314567614
   ("" (lemma "single_nz_series_conv") (("" (propax) nil nil)) nil)
   ((single_nz_series_conv formula-decl nil series_aux nil)) shostak))
 (single_nz_series_limit 0
  (single_nz_series_limit-1 nil 3314567245
   ("" (skosimp)
    (("" (lemma "zero_tail_series_limit" ("a" "a!1" "n" "n!1"))
      (("" (split -1)
        (("1" (expand "series" -1 2)
          (("1" (expand "sigma" -1)
            (("1" (case-replace "n!1=0")
              (("1" (assertnil nil)
               ("2"
                (lemma "sigma_restrict_eq"
                 ("low" "0" "high" "n!1-1" "F" "a!1" "G"
                  "lambda (i:nat): 0"))
                (("2" (rewrite "sigma_zero")
                  (("2" (split)
                    (("1" (replace -1) (("1" (assertnil nil)) nil)
                     ("2" (expand "restrict")
                      (("2" (apply-extensionality :hide? t)
                        (("2" (inst - "x!1")
                          (("2" (lift-if)
                            (("2" (prop) (("2" (assertnil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (skosimp)
          (("2" (inst - "m!1") (("2" (assertnil nil)) nil)) nil))
        nil))
      nil))
    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)
    (zero_tail_series_limit formula-decl nil series_aux nil)
    (series const-decl "sequence[real]" series nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (sigma_0_neg formula-decl nil sigma_nat "reals/")
    (sigma_zero formula-decl nil sigma "reals/")
    (restrict const-decl "[T -> real]" sigma "reals/")
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (> const-decl "bool" reals nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (sigma_restrict_eq formula-decl nil sigma "reals/")
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (T_high type-eq-decl nil sigma "reals/")
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (T_low type-eq-decl nil sigma "reals/")
    (sigma def-decl "real" sigma "reals/"))
   shostak))
 (single_nz_series 0
  (single_nz_series-1 nil 3321845412
   ("" (skosimp)
    (("" (lemma "single_nz_series_conv" ("a" "a!1" "n" "n!1"))
      (("" (lemma "single_nz_series_limit" ("a" "a!1" "n" "n!1"))
        (("" (assert)
          (("" (replace -3 (-1 -2))
            (("" (rewrite "limit_equiv") (("" (assertnil nil)) nil))
            nil))
          nil))
        nil))
      nil))
    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)
    (single_nz_series_conv formula-decl nil series_aux nil)
    (limit_equiv formula-decl nil convergence_ops "analysis/")
    (series const-decl "sequence[real]" series nil)
    (single_nz_series_limit formula-decl nil series_aux nil))
   shostak))
 (limit_nonneg 0
  (limit_nonneg-1 nil 3322859396
   ("" (skosimp)
    ((""
      (lemma "cnv_seq_order"
       ("s1" "LAMBDA n: 0" "s2" "nna!1" "l1" "0" "l2" "limit(nna!1)"))
      (("" (lemma "limit_equiv" ("s" "nna!1" "l" "limit(nna!1)"))
        (("" (simplify -1)
          (("" (replace -3 -1)
            (("" (simplify -1)
              (("" (replace -1 -2)
                (("" (split -2)
                  (("1" (assertnil nil)
                   ("2" (hide-all-but 1)
                    (("2" (expand "convergence")
                      (("2" (expand "abs") (("2" (propax) nil nil))
                        nil))
                      nil))
                    nil)
                   ("3" (hide-all-but 1)
                    (("3" (skosimp) (("3" (assertnil nil)) nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nnreal type-eq-decl nil real_types nil)
    (limit const-decl "real" convergence_sequences "analysis/")
    (convergent? const-decl "bool" convergence_sequences "analysis/")
    (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)
    (cnv_seq_order formula-decl nil convergence_ops "analysis/")
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (convergence const-decl "bool" convergence_sequences "analysis/")
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (limit_equiv formula-decl nil convergence_ops "analysis/"))
   shostak))
 (convergence_nonneg 0
  (convergence_nonneg-1 nil 3322862860
   ("" (skosimp*)
    (("" (case "FORALL m: n!1 < m => nna!1(m) = 0")
      (("1" (lemma "zero_tail_series" ("a" "nna!1" "n" "n!1"))
        (("1" (replace -2 -1)
          (("1"
            (lemma "unique_limit"
             ("u" "series(nna!1)" "l1" "nnx!1" "l2"
              "series(nna!1)(n!1)"))
            (("1" (assertnil nil)) nil))
          nil))
        nil)
       ("2" (skosimp)
        (("2" (expand "convergence")
          (("2" (inst - "nna!1(m!1)")
            (("1" (skosimp)
              (("1" (inst - "max(n!2,m!1)")
                (("1" (split -2)
                  (("1" (case "increasing?(series(nna!1))")
                    (("1" (expand "abs")
                      (("1"
                        (case-replace
                         "series(nna!1)(max(n!2, m!1)) - nnx!1 < 0")
                        (("1" (expand "increasing?")
                          (("1" (inst - "n!1" "max(n!2,m!1)")
                            (("1" (assertnil nil)) nil))
                          nil)
                         ("2" (assert)
                          (("2" (hide 1)
                            (("2" (expand "series")
                              (("2"
                                (expand "max")
                                (("2"
                                  (case-replace "n!2<m!1")
                                  (("1"
                                    (expand "sigma" -3)
                                    (("1"
                                      (assert)
                                      (("1"
                                        (expand "increasing?")
                                        (("1"
                                          (inst - "n!1" "m!1-1")
                                          (("1" (assertnil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (assert)
                                    (("2"
                                      (case "n!2 >= m!1")
                                      (("1"
                                        (hide 1)
                                        (("1"
                                          (expand ">=")
                                          (("1"
                                            (expand "<=" -1)
                                            (("1"
                                              (split -1)
                                              (("1"
                                                (lemma
                                                 "sigma_middle[nat]"
                                                 ("high"
                                                  "n!2"
                                                  "i"
                                                  "m!1"
                                                  "low"
                                                  "0"
                                                  "F"
                                                  "nna!1"))
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (replace -1 -4)
                                                    (("1"
                                                      (hide -1)
                                                      (("1"
                                                        (case
                                                         "forall m: 0 <= sigma(1 + m!1, 1+m!1+m, nna!1)")
                                                        (("1"
                                                          (inst
                                                           -
                                                           "n!2-m!1-1")
                                                          (("1"
                                                            (expand
                                                             "increasing?")
                                                            (("1"
                                                              (inst
                                                               -
                                                               "n!1"
                                                               "m!1-1")
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (hide-all-but
                                                           1)
                                                          (("2"
                                                            (induct
                                                             "m")
                                                            (("1"
                                                              (expand
                                                               "sigma")
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (expand
                                                                   "sigma")
                                                                  (("1"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (skosimp*)
                                                              (("2"
                                                                (expand
                                                                 "sigma"
                                                                 1)
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (replace -1 * rl)
                                                (("2"
                                                  (hide -1)
                                                  (("2"
                                                    (expand "sigma" -2)
                                                    (("2"
                                                      (expand
                                                       "increasing?")
                                                      (("2"
                                                        (inst
                                                         -
                                                         "n!1"
                                                         "m!1-1")
                                                        (("2"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2" (assertnil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide-all-but 1)
                      (("2" (expand "increasing?")
                        (("2" (expand "series")
                          (("2"
                            (case "forall n,m: sigma(0, n, nna!1) <= sigma(0, n+m, nna!1)")
                            (("1" (skosimp)
                              (("1"
                                (inst - "x!1" "y!1-x!1")
                                (("1" (assertnil nil)
                                 ("2" (assertnil nil))
                                nil))
                              nil)
                             ("2" (hide 2)
                              (("2"
                                (induct "m")
                                (("1"
                                  (skosimp)
                                  (("1" (assertnil nil))
                                  nil)
                                 ("2"
                                  (skosimp*)
                                  (("2"
                                    (inst - "n!3")
                                    (("2"
                                      (expand "sigma" 1 2)
                                      (("2" (assertnil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (expand "max")
                    (("2" (case-replace "n!2 < m!1")
                      (("1" (assertnil nil) ("2" (assertnil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (assertnil nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((sequence type-eq-decl nil sequences nil)
    (nnreal type-eq-decl nil real_types nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (< const-decl "bool" reals nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans 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_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (series const-decl "sequence[real]" series nil)
    (unique_limit formula-decl nil convergence_sequences "analysis/")
    (zero_tail_series formula-decl nil series_aux nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (convergence const-decl "bool" convergence_sequences "analysis/")
    (x!1 skolem-const-decl "nat" series_aux nil)
    (y!1 skolem-const-decl "nat" series_aux nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nnreal_plus_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (sigma_nnreal application-judgement "nnreal" sigma_nat "reals/")
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (sigma def-decl "real" sigma "reals/")
    (nat_induction formula-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (T_low type-eq-decl nil sigma "reals/")
    (T_high type-eq-decl nil sigma "reals/")
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (sigma_middle formula-decl nil sigma "reals/")
    (<= const-decl "bool" reals 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)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (increasing? const-decl "bool" real_fun_preds "reals/")
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (nat_max application-judgement "{k: nat | i <= k AND j <= k}"
     real_defs nil)
    (nonneg_rat_max application-judgement
     "{s: nonneg_rat | s >= q AND s >= r}" real_defs nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (m!1 skolem-const-decl "nat" series_aux nil)
    (nna!1 skolem-const-decl "sequence[nnreal]" series_aux nil)
    (> const-decl "bool" reals nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   shostak))
 (nonneg_series_bij 0
  (nonneg_series_bij-1 nil 3322860486
   ("" (skosimp*)
    (("" (typepred "phi!1")
      ((""
        (name "MM"
              "LAMBDA (f:(bijective?[nat,nat]),n:nat): image(LAMBDA (i:below[n+1]): f(i))(fullset[below[n+1]])")
        (("" (lemma "surjective_inverse_exists[nat,nat]" ("f" "phi!1"))
          (("" (lemma "bij_inv_is_bij_alt[nat,nat]" ("f" "phi!1"))
            (("" (skolem - ("phi1"))
              (("" (inst - "phi1")
                ((""
                  (case "forall (f: (bijective?[nat, nat]), n: nat): is_finite[nat](MM(f,n))")
                  (("1"
                    (case "FORALL (f: (bijective?[nat, nat]), n: nat): has_greatest?(MM(f,n),reals.<=)")
                    (("1" (expand "restrict")
                      (("1" (expand "has_greatest?")
                        (("1" (expand "greatest?")
                          (("1" (expand "upper_bound?")
                            (("1" (case "increasing?(series(nna!1))")
                              (("1"
                                (case
                                 "increasing?(series(nna!1 o phi!1))")
                                (("1"
                                  (case
                                   "FORALL n: EXISTS m: series(nna!1 o phi!1)(n) <= series(nna!1)(m)")
                                  (("1"
                                    (case
                                     "FORALL (a: sequence[nnreal], l: real):
                         increasing?(a) & convergence(a, l) => (FORALL (j: nat): a(j) <= l)")
                                    (("1"
                                      (inst - "series(nna!1)" "nnx!1")
                                      (("1"
                                        (assert)
                                        (("1"
                                          (case
                                           "FORALL (j: nat): series(nna!1 o phi!1)(j) <= nnx!1")
                                          (("1"
                                            (expand "convergence")
                                            (("1"
                                              (skosimp)
                                              (("1"
                                                (inst -12 "epsilon!1")
                                                (("1"
                                                  (skosimp)
                                                  (("1"
                                                    (case
                                                     "FORALL i: i >= n!1 IMPLIES nnx!1-series(nna!1)(i) < epsilon!1")
                                                    (("1"
                                                      (case
                                                       "EXISTS n:
                                 FORALL i:
                                   i >= n IMPLIES nnx!1 - series(nna!1 o phi!1)(i) < epsilon!1")
                                                      (("1"
                                                        (skosimp)
                                                        (("1"
                                                          (inst
                                                           +
                                                           "n!2")
                                                          (("1"
                                                            (skosimp)
                                                            (("1"
                                                              (inst
                                                               -
                                                               "i!1")
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (expand
                                                                   "abs"
                                                                   1)
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (inst
                                                                       -3
                                                                       "i!1")
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (expand
                                                                           "<="
                                                                           -3)
                                                                          (("1"
                                                                            (split
                                                                             -3)
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil)
                                                                             ("2"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (hide 2)
                                                        (("2"
                                                          (case
                                                           "FORALL n: EXISTS m: series(nna!1)(n) <= series(nna!1 o phi!1)(m)")
                                                          (("1"
                                                            (inst
                                                             -
                                                             "n!1")
                                                            (("1"
                                                              (skosimp)
                                                              (("1"
                                                                (inst
                                                                 -
                                                                 "n!1")
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (inst
                                                                     +
                                                                     "m!1")
                                                                    (("1"
                                                                      (skosimp)
                                                                      (("1"
                                                                        (expand
                                                                         "increasing?"
                                                                         -7)
                                                                        (("1"
                                                                          (inst
                                                                           -7
                                                                           "m!1"
                                                                           "i!1")
                                                                          (("1"
                                                                            (assert)
                                                                            nil
                                                                            nil)
                                                                           ("2"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (hide-all-but
                                                             (1
                                                              -12
                                                              -11
                                                              -10
                                                              -9
                                                              -8
                                                              -7
                                                              -5
                                                              -6))
                                                            (("2"
                                                              (skosimp)
                                                              (("2"
                                                                (inst
                                                                 -3
                                                                 "phi!1"
                                                                 "n!2")
                                                                (("2"
                                                                  (case
                                                                   " EXISTS (t: nat):
                                     MM(phi1, n!2)(t) AND
                                      (FORALL (r: (MM(phi1, n!2))): (reals.<=(r, t)))")
                                                                  (("1"
                                                                    (hide
                                                                     -4)
                                                                    (("1"
                                                                      (skosimp)
                                                                      (("1"
                                                                        (inst
                                                                         +
                                                                         "t!1")
                                                                        (("1"
                                                                          (case
                                                                           "FORALL (j: nat):
                                       j <= n!2 =>
                                        sigma(0, j, nna!1) =
                                         sigma(0, t!1,
                                               LAMBDA (i: nat):
                                                 IF MM(phi1, j)(i) THEN nna!1(phi!1(i)) ELSE 0 ENDIF)")
                                                                          (("1"
                                                                            (expand
                                                                             "series")
                                                                            (("1"
                                                                              (inst
                                                                               -
                                                                               "n!2")
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (replace
                                                                                   -1)
                                                                                  (("1"
                                                                                    (lemma
                                                                                     "sigma_le"
                                                                                     ("low"
                                                                                      "0"
                                                                                      "high"
                                                                                      "t!1"
                                                                                      "F"
                                                                                      "LAMBDA (i: nat):
                                           IF MM(phi1, n!2)(i) THEN nna!1(phi!1(i)) ELSE 0 ENDIF"
                                                                                      "G"
                                                                                      "nna!1 o phi!1"))
                                                                                    (("1"
                                                                                      (split
                                                                                       -1)
                                                                                      (("1"
                                                                                        (propax)
                                                                                        nil
                                                                                        nil)
                                                                                       ("2"
                                                                                        (hide
                                                                                         2)
                                                                                        (("2"
                                                                                          (skosimp)
                                                                                          (("2"
                                                                                            (expand
                                                                                             "o"
                                                                                             1)
                                                                                            (("2"
                                                                                              (case-replace
                                                                                               "MM(phi1, n!2)(n!3)")
                                                                                              (("1"
                                                                                                (assert)
                                                                                                nil
                                                                                                nil)
                                                                                               ("2"
                                                                                                (assert)
                                                                                                nil
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (hide
                                                                             2)
                                                                            (("2"
                                                                              (induct
                                                                               "j")
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (expand
                                                                                   "sigma"
                                                                                   1
                                                                                   1)
                                                                                  (("1"
                                                                                    (lemma
                                                                                     "sigma_with"
                                                                                     ("low"
                                                                                      "0"
                                                                                      "high"
                                                                                      "t!1"
                                                                                      "i"
                                                                                      "phi1(0)"
                                                                                      "a"
                                                                                      "nna!1(0)"
                                                                                      "F"
                                                                                      "LAMBDA (i: nat):
                                              IF MM(phi1, 0)(i) THEN nna!1(phi!1(i)) ELSE 0 ENDIF"
                                                                                      "G"
                                                                                      "LAMBDA (i:nat): 0"))
                                                                                    (("1"
                                                                                      (split
                                                                                       -1)
                                                                                      (("1"
                                                                                        (replace
                                                                                         -1)
                                                                                        (("1"
                                                                                          (lemma
                                                                                           "sigma_zero"
                                                                                           ("low"
                                                                                            "0"
                                                                                            "high"
                                                                                            "t!1"))
                                                                                          (("1"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil)
                                                                                       ("3"
                                                                                        (inst
                                                                                         -
                                                                                         "phi1(0)")
                                                                                        (("3"
                                                                                          (expand
                                                                                           "MM")
                                                                                          (("3"
                                                                                            (expand
                                                                                             "image")
                                                                                            (("3"
                                                                                              (expand
                                                                                               "image")
                                                                                              (("3"
                                                                                                (inst
                                                                                                 +
                                                                                                 "0")
                                                                                                (("3"
                                                                                                  (expand
                                                                                                   "fullset")
                                                                                                  (("3"
                                                                                                    (propax)
                                                                                                    nil
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("4"
                                                                                        (hide
                                                                                         2)
                                                                                        (("4"
                                                                                          (apply-extensionality
                                                                                           1
                                                                                           :hide?
                                                                                           t)
                                                                                          (("4"
                                                                                            (case-replace
                                                                                             "x!1=phi1(0)")
                                                                                            (("1"
                                                                                              (assert)
                                                                                              (("1"
                                                                                                (case-replace
                                                                                                 "MM(phi1, 0)(phi1(0))")
                                                                                                (("1"
                                                                                                  (lemma
                                                                                                   "comp_inverse_right_alt[nat,nat]"
                                                                                                   ("f"
                                                                                                    "phi!1"
                                                                                                    "g"
                                                                                                    "phi1"
                                                                                                    "r"
                                                                                                    "0"))
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    nil
                                                                                                    nil))
                                                                                                  nil)
                                                                                                 ("2"
                                                                                                  (hide
                                                                                                   2)
                                                                                                  (("2"
                                                                                                    (expand
                                                                                                     "MM")
                                                                                                    (("2"
                                                                                                      (expand
                                                                                                       "image")
                                                                                                      (("2"
                                                                                                        (expand
                                                                                                         "image")
                                                                                                        (("2"
                                                                                                          (inst
                                                                                                           +
                                                                                                           "0")
                                                                                                          (("2"
                                                                                                            (expand
                                                                                                             "fullset")
                                                                                                            (("2"
                                                                                                              (propax)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil)
                                                                                             ("2"
                                                                                              (assert)
                                                                                              (("2"
                                                                                                (lift-if
                                                                                                 2)
                                                                                                (("2"
                                                                                                  (case-replace
                                                                                                   "MM(phi1, 0)(x!1)")
                                                                                                  (("1"
                                                                                                    (expand
                                                                                                     "MM")
                                                                                                    (("1"
                                                                                                      (expand
                                                                                                       "image")
                                                                                                      (("1"
                                                                                                        (expand
                                                                                                         "image")
                                                                                                        (("1"
                                                                                                          (propax)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil)
                                                                                                   ("2"
                                                                                                    (assert)
                                                                                                    nil
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (skosimp*)
                                                                                (("2"
                                                                                  (assert)
                                                                                  (("2"
                                                                                    (expand
                                                                                     "sigma"
                                                                                     1
                                                                                     1)
                                                                                    (("2"
                                                                                      (replace
                                                                                       -1)
                                                                                      (("2"
                                                                                        (hide
                                                                                         -1)
                                                                                        (("2"
                                                                                          (lemma
                                                                                           "sigma_with"
                                                                                           ("low"
                                                                                            "0"
                                                                                            "high"
                                                                                            "t!1"
                                                                                            "F"
                                                                                            "LAMBDA (i: nat):
                                              IF MM(phi1, 1 + j!1)(i) THEN nna!1(phi!1(i)) ELSE 0 ENDIF"
                                                                                            "G"
                                                                                            "LAMBDA (i: nat):
                                              IF MM(phi1, j!1)(i) THEN nna!1(phi!1(i)) ELSE 0 ENDIF"
                                                                                            "i"
                                                                                            "phi1(1+j!1)"
                                                                                            "a"
                                                                                            "nna!1(1+j!1)"))
                                                                                          (("2"
                                                                                            (split
                                                                                             -1)
                                                                                            (("1"
                                                                                              (replace
                                                                                               -1
                                                                                               1)
                                                                                              (("1"
                                                                                                (assert)
                                                                                                (("1"
                                                                                                  (case
                                                                                                   "MM(phi1, j!1)(phi1(1 + j!1))")
                                                                                                  (("1"
                                                                                                    (hide
                                                                                                     1
                                                                                                     -2)
                                                                                                    (("1"
                                                                                                      (expand
                                                                                                       "MM")
                                                                                                      (("1"
                                                                                                        (expand
                                                                                                         "image")
                                                                                                        (("1"
                                                                                                          (expand
                                                                                                           "image")
                                                                                                          (("1"
                                                                                                            (skosimp)
                                                                                                            (("1"
                                                                                                              (typepred
                                                                                                               "x!1")
                                                                                                              (("1"
                                                                                                                (expand
                                                                                                                 "bijective?"
                                                                                                                 -10)
                                                                                                                (("1"
                                                                                                                  (flatten)
                                                                                                                  (("1"
                                                                                                                    (expand
                                                                                                                     "injective?")
                                                                                                                    (("1"
                                                                                                                      (inst
                                                                                                                       -10
                                                                                                                       "1+j!1"
                                                                                                                       "x!1")
                                                                                                                      (("1"
                                                                                                                        (assert)
                                                                                                                        nil
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil)
                                                                                                   ("2"
                                                                                                    (assert)
                                                                                                    nil
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil)
                                                                                             ("2"
                                                                                              (assert)
                                                                                              nil
                                                                                              nil)
                                                                                             ("3"
                                                                                              (assert)
                                                                                              (("3"
                                                                                                (inst
                                                                                                 -
                                                                                                 "phi1(1+j!1)")
                                                                                                (("3"
                                                                                                  (expand
                                                                                                   "MM")
                                                                                                  (("3"
                                                                                                    (expand
                                                                                                     "image")
                                                                                                    (("3"
                                                                                                      (expand
                                                                                                       "image")
                                                                                                      (("3"
                                                                                                        (inst
                                                                                                         +
                                                                                                         "1+j!1")
                                                                                                        (("3"
                                                                                                          (expand
                                                                                                           "fullset")
                                                                                                          (("3"
                                                                                                            (propax)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil)
                                                                                             ("4"
                                                                                              (hide
                                                                                               2)
                                                                                              (("4"
                                                                                                (apply-extensionality
                                                                                                 1
                                                                                                 :hide?
                                                                                                 t)
                                                                                                (("4"
                                                                                                  (case-replace
                                                                                                   "x!1=phi1(1 + j!1)")
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    (("1"
                                                                                                      (case-replace
                                                                                                       "MM(phi1, 1 + j!1)(phi1(1 + j!1))")
                                                                                                      (("1"
                                                                                                        (lemma
                                                                                                         "comp_inverse_right_alt[nat,nat]"
                                                                                                         ("f"
                                                                                                          "phi!1"
                                                                                                          "g"
                                                                                                          "phi1"
                                                                                                          "r"
                                                                                                          "1+j!1"))
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil)
                                                                                                       ("2"
                                                                                                        (hide
                                                                                                         2)
                                                                                                        (("2"
                                                                                                          (expand
                                                                                                           "MM")
                                                                                                          (("2"
                                                                                                            (expand
                                                                                                             "image")
                                                                                                            (("2"
                                                                                                              (expand
                                                                                                               "image")
                                                                                                              (("2"
                                                                                                                (inst
                                                                                                                 +
                                                                                                                 "1+j!1")
                                                                                                                (("2"
                                                                                                                  (expand
                                                                                                                   "fullset")
                                                                                                                  (("2"
                                                                                                                    (propax)
                                                                                                                    nil
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil)
                                                                                                   ("2"
                                                                                                    (assert)
                                                                                                    (("2"
                                                                                                      (case-replace
                                                                                                       "MM(phi1, 1 + j!1)(x!1)")
                                                                                                      (("1"
                                                                                                        (case-replace
                                                                                                         "MM(phi1,j!1)(x!1)")
                                                                                                        (("1"
                                                                                                          (hide
                                                                                                           3)
                                                                                                          (("1"
                                                                                                            (expand
                                                                                                             "MM")
                                                                                                            (("1"
                                                                                                              (expand
                                                                                                               "image")
                                                                                                              (("1"
                                                                                                                (expand
                                                                                                                 "image")
                                                                                                                (("1"
                                                                                                                  (skosimp)
                                                                                                                  (("1"
                                                                                                                    (typepred
                                                                                                                     "x!2")
                                                                                                                    (("1"
                                                                                                                      (inst
                                                                                                                       +
                                                                                                                       "x!2")
                                                                                                                      (("1"
                                                                                                                        (expand
                                                                                                                         "fullset")
                                                                                                                        (("1"
                                                                                                                          (assert)
                                                                                                                          nil
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil)
                                                                                                       ("2"
                                                                                                        (assert)
                                                                                                        (("2"
                                                                                                          (hide-all-but
                                                                                                           (-9
                                                                                                            1
                                                                                                            2
                                                                                                            3))
                                                                                                          (("2"
                                                                                                            (replace
                                                                                                             -1
                                                                                                             :dir
                                                                                                             RL
                                                                                                             :hide?
                                                                                                             t)
                                                                                                            (("2"
                                                                                                              (beta)
                                                                                                              (("2"
                                                                                                                (expand
                                                                                                                 "image")
                                                                                                                (("2"
                                                                                                                  (expand
                                                                                                                   "image")
                                                                                                                  (("2"
                                                                                                                    (lift-if)
                                                                                                                    (("2"
                                                                                                                      (ground)
                                                                                                                      (("2"
                                                                                                                        (skeep)
                                                                                                                        (("2"
                                                                                                                          (inst?)
                                                                                                                          (("2"
                                                                                                                            (typepred
                                                                                                                             "x")
                                                                                                                            (("2"
                                                                                                                              (expand
                                                                                                                               "fullset")
                                                                                                                              (("2"
                                                                                                                                (propax)
                                                                                                                                nil
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (hide
                                                                     2)
                                                                    (("2"
                                                                      (hide
                                                                       -3
                                                                       -7)
                                                                      (("2"
                                                                        (inst
                                                                         -
                                                                         "phi1"
                                                                         "n!2")
                                                                        (("2"
                                                                          (lemma
                                                                           "non_empty_finite_has_greatest[nat]"
                                                                           ("NF"
                                                                            "MM(phi1,n!2)"))
                                                                          (("1"
                                                                            (inst
                                                                             -
                                                                             "LAMBDA (i,j:nat): reals.<=(i,j)")
                                                                            (("1"
                                                                              (expand
                                                                               "has_greatest?")
                                                                              (("1"
                                                                                (expand
                                                                                 "greatest?")
                                                                                (("1"
                                                                                  (expand
                                                                                   "upper_bound?")
                                                                                  (("1"
                                                                                    (propax)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (hide-all-but
                                                                               1)
                                                                              (("2"
                                                                                (grind)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (assert)
                                                                            (("2"
                                                                              (expand
                                                                               "empty?")
                                                                              (("2"
                                                                                (expand
                                                                                 "member")
                                                                                (("2"
                                                                                  (hide-all-but
                                                                                   -1)
                                                                                  (("2"
                                                                                    (expand
                                                                                     "MM")
                                                                                    (("2"
                                                                                      (expand
                                                                                       "fullset")
                                                                                      (("2"
                                                                                        (expand
                                                                                         "image")
                                                                                        (("2"
                                                                                          (expand
                                                                                           "image")
                                                                                          (("2"
                                                                                            (inst
                                                                                             -
                                                                                             "phi1(0)")
                                                                                            (("2"
                                                                                              (inst
                                                                                               +
                                                                                               "0")
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("3"
                                                        (skosimp)
                                                        (("3"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (hide 2)
                                                      (("2"
                                                        (skosimp)
                                                        (("2"
                                                          (inst
                                                           -13
                                                           "i!1")
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (inst
                                                               -3
                                                               "i!1")
                                                              (("1"
                                                                (expand
                                                                 "abs")
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("3"
                                                      (skosimp)
                                                      (("3"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (hide-all-but (-1 -2 1))
                                            (("2"
                                              (skosimp)
                                              (("2"
                                                (inst -2 "j!1")
                                                (("2"
                                                  (skosimp)
                                                  (("2"
                                                    (inst - "m!1")
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (skosimp)
                                        (("2"
                                          (expand "increasing?")
                                          (("2"
                                            (hide-all-but (-3 1))
                                            (("2"
                                              (inst - "0" "x1!1")
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (expand
                                                   "series"
                                                   -1
                                                   1)
                                                  (("2"
                                                    (expand "sigma")
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (hide-all-but 1)
                                      (("2"
                                        (skosimp)
                                        (("2"
                                          (lemma
                                           "convergence_cauchy"
                                           ("u" "a!1"))
                                          (("2"
                                            (lemma
                                             "cauchy_bounded"
                                             ("u" "a!1"))
                                            (("2"
                                              (replace -2 -1 rl)
                                              (("2"
                                                (lemma
                                                 "increasing_bounded_convergence"
                                                 ("v1" "a!1"))
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (lemma
                                                     "unique_limit"
                                                     ("u"
                                                      "a!1"
                                                      "l1"
                                                      "l!1"
                                                      "l2"
                                                      "sup(a!1)"))
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (replace -1)
                                                        (("1"
                                                          (expand
                                                           "sup")
                                                          (("1"
                                                            (typepred
                                                             "lub(Im(a!1))")
                                                            (("1"
                                                              (expand
                                                               "least_upper_bound?")
                                                              (("1"
                                                                (flatten)
                                                                (("1"
                                                                  (expand
                                                                   "upper_bound?")
                                                                  (("1"
                                                                    (skosimp)
                                                                    (("1"
                                                                      (inst
                                                                       -
                                                                       "a!1(j!1)")
                                                                      (("1"
                                                                        (expand
                                                                         "Im")
                                                                        (("1"
                                                                          (inst
                                                                           +
                                                                           "j!1")
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (split -1)
                                                  (("1"
                                                    (flatten)
                                                    nil
                                                    nil)
                                                   ("2"
                                                    (expand
                                                     "convergent?")
                                                    (("2"
                                                      (inst + "l!1")
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (hide 2)
                                    (("2"
                                      (skosimp)
                                      (("2"
                                        (inst - "phi!1" "n!1")
                                        (("2"
                                          (skosimp)
                                          (("2"
                                            (inst + "t!1")
                                            (("2"
                                              (case
                                               "series(nna!1 o phi!1)(n!1) =
                        series(LAMBDA (i: nat):
                                 IF MM(phi!1, n!1)(i) THEN nna!1(i) ELSE 0 ENDIF)
                              (t!1)")
                                              (("1"
                                                (replace -1 1)
                                                (("1"
                                                  (hide -1)
                                                  (("1"
                                                    (expand "series")
                                                    (("1"
                                                      (lemma
                                                       "sigma_le"
                                                       ("low"
                                                        "0"
                                                        "high"
                                                        "t!1"
                                                        "F"
                                                        "LAMBDA (i: nat):
                             IF MM(phi!1, n!1)(i) THEN nna!1(i) ELSE 0 ENDIF"
                                                        "G"
                                                        "nna!1"))
                                                      (("1"
                                                        (split -1)
                                                        (("1"
                                                          (propax)
                                                          nil
                                                          nil)
                                                         ("2"
                                                          (hide 2)
                                                          (("2"
                                                            (skosimp)
                                                            (("2"
                                                              (typepred
                                                               "n!2")
                                                              (("2"
                                                                (case-replace
                                                                 "MM(phi!1, n!1)(n!2)")
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil)
                                                                 ("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (hide-all-but
                                                 (1
                                                  -9
                                                  -3
                                                  -4
                                                  -5
                                                  -6
                                                  -7
                                                  -9))
                                                (("2"
                                                  (expand "series")
                                                  (("2"
                                                    (case
                                                     "forall (j:nat): j <= n!1 => sigma(0, j, nna!1 o phi!1) =
                          sigma(0, t!1,
                                LAMBDA (i: nat):
                                  IF MM(phi!1, j)(i) THEN nna!1(i) ELSE 0 ENDIF)")
                                                    (("1"
                                                      (inst - "n!1")
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (hide 2)
                                                      (("2"
                                                        (induct "j")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (expand
                                                             "sigma"
                                                             1
                                                             1)
                                                            (("1"
                                                              (expand
                                                               "o"
                                                               1)
                                                              (("1"
                                                                (inst
                                                                 -2
                                                                 "phi!1(0)")
                                                                (("1"
                                                                  (typepred
                                                                   "phi!1(0)")
                                                                  (("1"
                                                                    (lemma
                                                                     "sigma_with"
                                                                     ("low"
                                                                      "0"
                                                                      "high"
                                                                      "t!1"
                                                                      "F"
                                                                      "LAMBDA (i: nat): IF MM(phi!1, 0)(i) THEN nna!1(i) ELSE 0 ENDIF"
                                                                      "G"
                                                                      "LAMBDA (i:nat): 0"
                                                                      "a"
                                                                      "nna!1(phi!1(0))"
                                                                      "i"
                                                                      "phi!1(0)"))
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (split
                                                                         -1)
                                                                        (("1"
                                                                          (replace
                                                                           -1)
                                                                          (("1"
                                                                            (lemma
                                                                             "sigma_zero"
                                                                             ("low"
                                                                              "0"
                                                                              "high"
                                                                              "t!1"))
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (hide
                                                                           2)
                                                                          (("2"
                                                                            (apply-extensionality
                                                                             1
                                                                             :hide?
                                                                             t)
                                                                            (("2"
                                                                              (lift-if
                                                                               1)
                                                                              (("2"
                                                                                (case-replace
                                                                                 "MM(phi!1, 0)(x!1)")
                                                                                (("1"
                                                                                  (assert)
                                                                                  (("1"
                                                                                    (case-replace
                                                                                     "x!1=phi!1(0)")
                                                                                    (("1"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil)
                                                                                     ("2"
                                                                                      (assert)
                                                                                      (("2"
                                                                                        (expand
                                                                                         "MM")
                                                                                        (("2"
                                                                                          (expand
                                                                                           "image")
                                                                                          (("2"
                                                                                            (expand
                                                                                             "image")
                                                                                            (("2"
                                                                                              (propax)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (assert)
                                                                                  (("2"
                                                                                    (case-replace
                                                                                     "x!1=phi!1(0)")
                                                                                    (("1"
                                                                                      (assert)
                                                                                      (("1"
                                                                                        (expand
                                                                                         "MM")
                                                                                        (("1"
                                                                                          (expand
                                                                                           "image")
                                                                                          (("1"
                                                                                            (expand
                                                                                             "image")
                                                                                            (("1"
                                                                                              (inst
                                                                                               +
                                                                                               "0")
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "fullset")
                                                                                                (("1"
                                                                                                  (propax)
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (expand
                                                                   "MM")
                                                                  (("2"
                                                                    (expand
                                                                     "image")
                                                                    (("2"
                                                                      (expand
                                                                       "image")
                                                                      (("2"
                                                                        (inst
                                                                         +
                                                                         "0")
                                                                        (("2"
                                                                          (expand
                                                                           "fullset")
                                                                          (("2"
                                                                            (propax)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (skosimp*)
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (expand
                                                               "sigma"
                                                               1
                                                               1)
                                                              (("2"
                                                                (replace
                                                                 -1
                                                                 1)
                                                                (("2"
                                                                  (hide
                                                                   -1)
                                                                  (("2"
                                                                    (lemma
                                                                     "sigma_with"
                                                                     ("low"
                                                                      "0"
                                                                      "high"
                                                                      "t!1"
                                                                      "G"
                                                                      "LAMBDA (i:nat): IF MM(phi!1, j!1)(i) THEN nna!1(i) ELSE 0 ENDIF"
                                                                      "F"
                                                                      "LAMBDA (i:nat): IF MM(phi!1, 1 + j!1)(i) THEN nna!1(i) ELSE 0 ENDIF"
                                                                      "i"
                                                                      "phi!1(1+j!1)"
                                                                      "a"
                                                                      "nna!1(phi!1(1+j!1))"))
                                                                    (("2"
                                                                      (typepred
                                                                       "phi!1(1+j!1)")
                                                                      (("2"
                                                                        (inst
                                                                         -5
                                                                         "phi!1(1+j!1)")
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (split
                                                                             -2)
                                                                            (("1"
                                                                              (replace
                                                                               -1
                                                                               1)
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (expand
                                                                                   "o"
                                                                                   1)
                                                                                  (("1"
                                                                                    (lift-if
                                                                                     1)
                                                                                    (("1"
                                                                                      (assert)
                                                                                      (("1"
                                                                                        (case-replace
                                                                                         "MM(phi!1, j!1)(phi!1(1 + j!1))")
                                                                                        (("1"
                                                                                          (expand
                                                                                           "MM")
                                                                                          (("1"
                                                                                            (expand
                                                                                             "image")
                                                                                            (("1"
                                                                                              (expand
                                                                                               "image")
                                                                                              (("1"
                                                                                                (skosimp)
                                                                                                (("1"
                                                                                                  (typepred
                                                                                                   "x!1")
                                                                                                  (("1"
                                                                                                    (hide-all-but
                                                                                                     (-1
                                                                                                      -2
                                                                                                      -3
                                                                                                      -12))
                                                                                                    (("1"
                                                                                                      (expand
                                                                                                       "bijective?")
                                                                                                      (("1"
                                                                                                        (flatten)
                                                                                                        (("1"
                                                                                                          (expand
                                                                                                           "injective?")
                                                                                                          (("1"
                                                                                                            (inst
                                                                                                             -
                                                                                                             "1+j!1"
                                                                                                             "x!1")
                                                                                                            (("1"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (assert)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (hide
                                                                               2)
                                                                              (("2"
                                                                                (apply-extensionality
                                                                                 1
                                                                                 :hide?
                                                                                 t)
                                                                                (("2"
                                                                                  (case-replace
                                                                                   "x!1=phi!1(1 + j!1)")
                                                                                  (("1"
                                                                                    (assert)
                                                                                    (("1"
                                                                                      (lift-if
                                                                                       1)
                                                                                      (("1"
                                                                                        (case-replace
                                                                                         "MM(phi!1, 1 + j!1)(phi!1(1 + j!1))")
                                                                                        (("1"
                                                                                          (assert)
                                                                                          (("1"
                                                                                            (expand
                                                                                             "MM")
                                                                                            (("1"
                                                                                              (expand
                                                                                               "image")
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "image")
                                                                                                (("1"
                                                                                                  (inst
                                                                                                   +
                                                                                                   "1+j!1")
                                                                                                  (("1"
                                                                                                    (expand
                                                                                                     "fullset")
                                                                                                    (("1"
                                                                                                      (propax)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil)
                                                                                   ("2"
                                                                                    (assert)
                                                                                    (("2"
                                                                                      (case-replace
                                                                                       "MM(phi!1, j!1)(x!1)")
                                                                                      (("1"
                                                                                        (case-replace
                                                                                         "MM(phi!1, 1+j!1)(x!1)")
                                                                                        (("1"
                                                                                          (expand
                                                                                           "MM")
                                                                                          (("1"
                                                                                            (expand
                                                                                             "image")
                                                                                            (("1"
                                                                                              (expand
                                                                                               "image")
                                                                                              (("1"
                                                                                                (skosimp)
                                                                                                (("1"
                                                                                                  (typepred
                                                                                                   "x!2")
                                                                                                  (("1"
                                                                                                    (inst
                                                                                                     +
                                                                                                     "x!2")
                                                                                                    (("1"
                                                                                                      (expand
                                                                                                       "fullset")
                                                                                                      (("1"
                                                                                                        (propax)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (assert)
                                                                                        (("2"
                                                                                          (case-replace
                                                                                           "MM(phi!1, 1 + j!1)(x!1)")
                                                                                          (("1"
                                                                                            (expand
                                                                                             "MM")
                                                                                            (("1"
                                                                                              (expand
                                                                                               "image")
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "image")
                                                                                                (("1"
                                                                                                  (skosimp)
                                                                                                  (("1"
                                                                                                    (typepred
                                                                                                     "x!2")
                                                                                                    (("1"
                                                                                                      (inst
                                                                                                       +
                                                                                                       "x!2")
                                                                                                      (("1"
                                                                                                        (expand
                                                                                                         "fullset")
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (hide
                                                                           -2
                                                                           2)
                                                                          (("2"
                                                                            (expand
                                                                             "MM")
                                                                            (("2"
                                                                              (expand
                                                                               "image")
                                                                              (("2"
                                                                                (expand
                                                                                 "image")
                                                                                (("2"
                                                                                  (inst
                                                                                   +
                                                                                   "1+j!1")
                                                                                  (("2"
                                                                                    (expand
                                                                                     "fullset")
                                                                                    (("2"
                                                                                      (propax)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (hide-all-but 1)
                                  (("2"
                                    (expand "increasing?")
                                    (("2"
                                      (expand "o ")
                                      (("2"
                                        (expand "series")
                                        (("2"
                                          (skosimp*)
                                          (("2"
                                            (expand "<=" -1)
                                            (("2"
                                              (split -1)
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (lemma
                                                   "sigma_zero"
                                                   ("low"
                                                    "1+x!1"
                                                    "high"
                                                    "y!1"))
                                                  (("1"
                                                    (lemma
                                                     "sigma_le"
                                                     ("low"
                                                      "1+x!1"
                                                      "high"
                                                      "y!1"
                                                      "F"
                                                      "LAMBDA (i: nat): 0"
                                                      "G"
                                                      "LAMBDA (x: nat): nna!1(phi!1(x))"))
                                                    (("1"
                                                      (split -1)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (replace -2)
                                                          (("1"
                                                            (hide -2)
                                                            (("1"
                                                              (lemma
                                                               "sigma_split"
                                                               ("low"
                                                                "0"
                                                                "high"
                                                                "y!1"
                                                                "z"
                                                                "x!1"
                                                                "F"
                                                                "LAMBDA (x: nat): nna!1(phi!1(x))"))
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (hide-all-but
                                                         1)
                                                        (("2"
                                                          (skosimp*)
                                                          (("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2" (assertnil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide-all-but 1)
                                (("2"
                                  (expand "increasing?")
                                  (("2"
                                    (expand "series")
                                    (("2"
                                      (skosimp*)
                                      (("2"
                                        (expand "<=" -1)
                                        (("2"
                                          (split -1)
                                          (("1"
                                            (assert)
                                            (("1"
                                              (hide -1)
                                              (("1"
                                                (lemma
                                                 "sigma_le"
                                                 ("low"
                                                  "1+x!1"
                                                  "high"
                                                  "y!1"
                                                  "F"
                                                  "lambda (i:nat): 0"
                                                  "G"
                                                  "nna!1"))
                                                (("1"
                                                  (split -1)
                                                  (("1"
                                                    (lemma
                                                     "sigma_zero"
                                                     ("low"
                                                      "1+x!1"
                                                      "high"
                                                      "y!1"))
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (reveal -1)
                                                        (("1"
                                                          (replace
                                                           -2
                                                           -3)
                                                          (("1"
                                                            (hide -2)
                                                            (("1"
                                                              (lemma
                                                               "sigma_split"
                                                               ("low"
                                                                "0"
                                                                "high"
                                                                "y!1"
                                                                "z"
                                                                "x!1"
                                                                "F"
                                                                "nna!1"))
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (skosimp)
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2" (assertnil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide-all-but (1 -1))
                      (("2" (skosimp)
                        (("2" (inst - "f!1" "n!1")
                          (("2" (expand "restrict")
                            (("2"
                              (lemma
                               "non_empty_finite_has_greatest[nat]"
                               ("NF"
                                "MM(f!1,n!1)"
                                "le"
                                "LAMBDA (s: [nat, nat]): reals.<=(s)"))
                              (("1" (propax) nil nil)
                               ("2"
                                (hide-all-but 1)
                                (("2" (grind) nil nil))
                                nil)
                               ("3"
                                (assert)
                                (("3"
                                  (expand "empty?")
                                  (("3"
                                    (expand "member")
                                    (("3"
                                      (expand "MM")
                                      (("3"
                                        (expand "fullset")
                                        (("3"
                                          (expand "image")
                                          (("3"
                                            (expand "image")
                                            (("3"
                                              (inst - "f!1(0)")
                                              (("3"
                                                (inst + "0")
                                                nil
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (hide 2 -3)
                    (("2" (skosimp)
                      (("2" (expand "MM")
                        (("2"
                          (lemma "finite_image[below[1+n!1],nat]"
                           ("f" "f!1" "S" "fullset[below[1 + n!1]]"))
                          (("1" (expand "restrict")
                            (("1" (expand "image")
                              (("1"
                                (expand "image")
                                (("1" (propax) nil nil))
                                nil))
                              nil))
                            nil)
                           ("2" (hide 2)
                            (("2" (expand "fullset")
                              (("2"
                                (expand "is_finite")
                                (("2"
                                  (inst
                                   +
                                   "1+n!1"
                                   "LAMBDA (n:below[1+n!1]): n")
                                  (("2"
                                    (expand "injective?")
                                    (("2" (skosimp) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((bijective? const-decl "bool" functions nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real 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)
    (number nonempty-type-decl nil numbers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (surjective_inverse_exists formula-decl nil function_inverse_def
     nil)
    (surjective? const-decl "bool" functions nil)
    (is_finite const-decl "bool" finite_sets nil)
    (greatest? const-decl "bool" minmax_orders "orders/")
    (increasing? const-decl "bool" real_fun_preds "reals/")
    (sequence type-eq-decl nil sequences nil)
    (series const-decl "sequence[real]" series nil)
    (nnreal type-eq-decl nil real_types nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (sigma_split formula-decl nil sigma "reals/")
    (convergence_cauchy formula-decl nil convergence_sequences
     "analysis/")
    (convergent? const-decl "bool" convergence_sequences "analysis/")
    (upper_bound? const-decl "bool" bounded_real_defs nil)
    (a!1 skolem-const-decl "sequence[nnreal]" series_aux nil)
    (j!1 skolem-const-decl "nat" series_aux nil)
    (Im const-decl "setof[real]" real_fun_props "reals/")
    (setof type-eq-decl nil defined_types nil)
    (lub const-decl "{x | least_upper_bound?(x, SA)}" bounded_real_defs
     nil)
    (bounded_above? const-decl "bool" bounded_real_defs nil)
    (least_upper_bound? const-decl "bool" bounded_real_defs nil)
    (nonempty? const-decl "bool" sets nil)
    (nonempty_image application-judgement "(nonempty?[real])"
     real_fun_supinf "analysis/")
    (sup const-decl "real" real_fun_supinf "analysis/")
    (unique_limit formula-decl nil convergence_sequences "analysis/")
    (bounded_above? const-decl "bool" real_fun_preds "reals/")
    (increasing_bounded_convergence formula-decl nil
     convergence_sequences "analysis/")
    (cauchy_bounded formula-decl nil convergence_sequences "analysis/")
    (nna!1 skolem-const-decl "sequence[nnreal]" series_aux nil)
    (i!1 skolem-const-decl "int" series_aux nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (minus_real_is_real application-judgement "real" reals 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)
    (i!1 skolem-const-decl "int" series_aux nil)
    (sigma_nnreal application-judgement "nnreal" sigma_nat "reals/")
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (T_low type-eq-decl nil sigma "reals/")
    (T_high type-eq-decl nil sigma "reals/")
    (sigma def-decl "real" sigma "reals/")
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (subrange type-eq-decl nil integers nil)
    (sigma_le formula-decl nil sigma "reals/")
    (nat_induction formula-decl nil naturalnumbers nil)
    (sigma_zero formula-decl nil sigma "reals/")
    (sigma_nat application-judgement "nat" sigma_nat "reals/")
    (real_plus_real_is_real application-judgement "real" reals nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nnreal_plus_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (sigma_0_neg formula-decl nil sigma_nat "reals/")
    (image const-decl "set[R]" function_image nil)
    (n!2 skolem-const-decl "nat" series_aux nil)
    (MM skolem-const-decl "[[(bijective?[nat, nat]), nat] -> set[nat]]"
     series_aux nil)
    (comp_inverse_right_alt formula-decl nil function_inverse_def nil)
    (sigma_with formula-decl nil sigma "reals/")
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (x!2 skolem-const-decl "(fullset[below[2 + j!1]])" series_aux nil)
    (x skolem-const-decl "(fullset[below[1 + j!1]])" series_aux nil)
    (j!1 skolem-const-decl "nat" series_aux nil)
    (injective? const-decl "bool" functions nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (non_empty_finite_has_greatest formula-decl nil minmax_orders
     "orders/")
    (finite_set type-eq-decl nil finite_sets nil)
    (empty? const-decl "bool" sets nil)
    (non_empty_finite_set type-eq-decl nil finite_sets nil)
    (dichotomous? const-decl "bool" orders nil)
    (partial_order? const-decl "bool" orders nil)
    (antisymmetric? const-decl "bool" relations nil)
    (preorder? const-decl "bool" orders nil)
    (transitive? const-decl "bool" relations nil)
    (reflexive? const-decl "bool" relations nil)
    (total_order? const-decl "bool" orders nil)
    (TRUE const-decl "bool" booleans nil)
    (member const-decl "bool" sets nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (convergence const-decl "bool" convergence_sequences "analysis/")
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (x!2 skolem-const-decl "(fullset[below[1 + j!1]])" series_aux nil)
    (x!2 skolem-const-decl "(fullset[below[2 + j!1]])" series_aux nil)
    (j!1 skolem-const-decl "nat" series_aux nil)
    (n!1 skolem-const-decl "nat" series_aux nil)
    (O const-decl "T3" function_props nil)
    (upper_bound? const-decl "bool" bounded_orders "orders/")
    (<= const-decl "bool" reals nil)
    (restrict const-decl "R" restrict nil)
    (has_greatest? const-decl "bool" minmax_orders "orders/")
    (pred type-eq-decl nil defined_types nil)
    (reflexive_restrict application-judgement "(reflexive?[S])"
     restrict_order_props nil)
    (antisymmetric_restrict application-judgement "(antisymmetric?[S])"
     restrict_order_props nil)
    (transitive_restrict application-judgement "(transitive?[S])"
     restrict_order_props nil)
    (preorder_restrict application-judgement "(preorder?[S])"
     restrict_order_props nil)
    (partial_order_restrict application-judgement "(partial_order?[S])"
     restrict_order_props nil)
    (dichotomous_restrict application-judgement "(dichotomous?[S])"
     restrict_order_props nil)
    (total_order_restrict application-judgement "(total_order?[S])"
     restrict_order_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (finite_image judgement-tcc nil function_image_aux nil)
    (phi!1 skolem-const-decl "(bijective?[nat, nat])" series_aux nil)
    (phi1 skolem-const-decl "[nat -> nat]" series_aux nil)
    (inverse? const-decl "bool" function_inverse_def nil)
    (bij_inv_is_bij_alt formula-decl nil function_inverse_def nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (set type-eq-decl nil sets nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (< const-decl "bool" reals nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (below type-eq-decl nil nat_types nil)
    (image const-decl "set[R]" function_image nil)
    (fullset const-decl "set" sets nil))
   shostak))
 (nonneg_series_bij_conv 0
  (nonneg_series_bij_conv-1 nil 3322860950
   ("" (skosimp)
    (("" (expand "convergent?")
      (("" (skosimp)
        (("" (inst + "l!1")
          ((""
            (lemma "nonneg_series_bij"
             ("nna" "nna!1" "phi" "phi!1" "nnx" "l!1"))
            (("1" (assertnil nil)
             ("2" (lemma "limit_nonneg" ("nna" "series(nna!1)"))
              (("1" (rewrite "limit_equiv" -2)
                (("1" (flatten) (("1" (assertnil nil)) nil)) nil)
               ("2" (hide-all-but 1)
                (("2" (expand "series")
                  (("2" (induct "x1")
                    (("1" (expand "sigma") (("1" (assertnil nil))
                      nil)
                     ("2" (skosimp*)
                      (("2" (expand "sigma" 1) (("2" (assertnil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((convergent? const-decl "bool" convergence_sequences "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)
    (limit_nonneg formula-decl nil series_aux nil)
    (series const-decl "sequence[real]" series nil)
    (limit_equiv formula-decl nil convergence_ops "analysis/")
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (nnreal_plus_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (sigma_nnreal application-judgement "nnreal" sigma_nat "reals/")
    (sigma_0_neg formula-decl nil sigma_nat "reals/")
    (nat_induction formula-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (T_low type-eq-decl nil sigma "reals/")
    (T_high type-eq-decl nil sigma "reals/")
    (sigma def-decl "real" sigma "reals/")
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (nonneg_series_bij formula-decl nil series_aux 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)
    (nnreal type-eq-decl nil real_types nil)
    (sequence type-eq-decl nil sequences nil)
    (bijective? const-decl "bool" functions nil))
   shostak))
 (nonneg_series_bij_limit_TCC1 0
  (nonneg_series_bij_limit_TCC1-1 nil 3322861248
   ("" (skosimp)
    (("" (lemma "nonneg_series_bij_conv" ("nna" "nna!1" "phi" "phi!1"))
      (("" (assertnil nil)) nil))
    nil)
   ((bijective? const-decl "bool" functions nil)
    (sequence type-eq-decl nil sequences nil)
    (nnreal type-eq-decl nil real_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (nonneg_series_bij_conv formula-decl nil series_aux nil))
   shostak))
 (nonneg_series_bij_limit 0
  (nonneg_series_bij_limit-1 nil 3322861180
   ("" (skosimp)
    (("" (lemma "nonneg_series_bij_conv" ("nna" "nna!1" "phi" "phi!1"))
      (("" (assert)
        (("" (expand "convergent?")
          (("" (skosimp*)
            ((""
              (lemma "nonneg_series_bij"
               ("nna" "nna!1" "phi" "phi!1" "nnx" "l!2"))
              (("1" (assert)
                (("1"
                  (lemma "unique_limit"
                   ("u" "series(nna!1 o phi!1)" "l1" "l!1" "l2" "l!2"))
                  (("1" (assert)
                    (("1" (rewrite "limit_equiv" -2)
                      (("1" (rewrite "limit_equiv" -4)
                        (("1" (assertnil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (hide -1 2)
                (("2" (lemma "limit_nonneg" ("nna" "series(nna!1)"))
                  (("1" (assert)
                    (("1"
                      (lemma "limit_def"
                       ("v" "series(nna!1)" "l" "l!2"))
                      (("1" (assertnil nil)) nil))
                    nil)
                   ("2" (hide-all-but 1)
                    (("2" (expand "series")
                      (("2" (induct "x1")
                        (("1" (expand "sigma") (("1" (assertnil nil))
                          nil)
                         ("2" (skosimp)
                          (("2" (expand "sigma" 1)
                            (("2" (assertnil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((bijective? const-decl "bool" functions nil)
    (sequence type-eq-decl nil sequences nil)
    (nnreal type-eq-decl nil real_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (nonneg_series_bij_conv formula-decl nil series_aux nil)
    (convergent? const-decl "bool" convergence_sequences "analysis/")
    (nonneg_series_bij formula-decl nil series_aux nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (unique_limit formula-decl nil convergence_sequences "analysis/")
    (series const-decl "sequence[real]" series nil)
    (O const-decl "T3" function_props nil)
    (limit_equiv formula-decl nil convergence_ops "analysis/")
    (limit_nonneg formula-decl nil series_aux nil)
    (limit_def formula-decl nil convergence_sequences "analysis/")
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (nnreal_plus_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (sigma_nnreal application-judgement "nnreal" sigma_nat "reals/")
    (sigma_0_neg formula-decl nil sigma_nat "reals/")
    (nat_induction formula-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (T_low type-eq-decl nil sigma "reals/")
    (T_high type-eq-decl nil sigma "reals/")
    (sigma def-decl "real" sigma "reals/"))
   shostak))
 (abs_series_bij 0
  (abs_series_bij-1 nil 3322870394
   ("" (skosimp)
    ((""
      (name "AA"
            "lambda (n:nat): IF a!1(n) < 0 THEN 0 ELSE a!1(n) ENDIF")
      ((""
        (name "BB"
              "lambda (n:nat): IF a!1(n) < 0 THEN -a!1(n) ELSE 0 ENDIF")
        (("" (case "a!1 = AA-BB")
          (("1" (hide -2 -3)
            (("1" (case "convergent?(series(AA))")
              (("1" (case "convergent?(series(BB))")
                (("1" (replace -3)
                  (("1" (hide -3 -4)
                    (("1" (expand "convergent?")
                      (("1" (skosimp*)
                        (("1" (assert)
                          (("1"
                            (lemma "nonneg_series_bij"
                             ("nna" "AA" "nnx" "l!2" "phi" "phi!1"))
                            (("1"
                              (lemma "nonneg_series_bij"
                               ("nna" "BB" "nnx" "l!1" "phi" "phi!1"))
                              (("1"
                                (assert)
                                (("1"
                                  (case-replace
                                   "series(AA) - series(BB) = series(AA - BB)")
                                  (("1"
                                    (case-replace
                                     "series(AA o phi!1) - series(BB o phi!1) = series((AA -BB)o phi!1)")
                                    (("1"
                                      (lemma
                                       "unique_limit"
                                       ("u"
                                        "series(AA - BB)"
                                        "l1"
                                        "l!2-l!1"
                                        "l2"
                                        "x!1"))
                                      (("1"
                                        (assert)
                                        (("1"
                                          (replace -3 -1 rl)
                                          (("1"
                                            (lemma
                                             "cnv_seq_diff"
                                             ("s1"
                                              "series(AA)"
                                              "s2"
                                              "series(BB)"
                                              "l1"
                                              "l!2"
                                              "l2"
                                              "l!1"))
                                            (("1"
                                              (assert)
                                              (("1"
                                                (replace -2)
                                                (("1"
                                                  (replace -3 1 rl)
                                                  (("1"
                                                    (lemma
                                                     "cnv_seq_diff"
                                                     ("s1"
                                                      "series(AA o phi!1)"
                                                      "s2"
                                                      "series(BB o phi!1)"
                                                      "l1"
                                                      "l!2"
                                                      "l2"
                                                      "l!1"))
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (hide-all-but
                                                         (1 -5 -6))
                                                        (("1"
                                                          (expand "o")
                                                          (("1"
                                                            (expand
                                                             "series")
                                                            (("1"
                                                              (expand
                                                               "convergence")
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (split
                                                                   1)
                                                                  (("1"
                                                                    (propax)
                                                                    nil
                                                                    nil)
                                                                   ("2"
                                                                    (propax)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (hide-all-but 1)
                                      (("2"
                                        (expand "o")
                                        (("2"
                                          (expand "series")
                                          (("2"
                                            (apply-extensionality
                                             :hide?
                                             t)
                                            (("2"
                                              (expand "-")
                                              (("2"
                                                (lemma
                                                 "sigma_minus[nat]"
                                                 ("low"
                                                  "0"
                                                  "high"
                                                  "x!2"
                                                  "F"
                                                  "LAMBDA (x: nat): AA(phi!1(x))"
                                                  "G"
                                                  "LAMBDA (x: nat): BB(phi!1(x))"))
                                                (("2"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (hide-all-but 1)
                                    (("2"
                                      (expand "series")
                                      (("2"
                                        (apply-extensionality :hide? t)
                                        (("2"
                                          (expand "-")
                                          (("2"
                                            (lemma
                                             "sigma_minus[nat]"
                                             ("low"
                                              "0"
                                              "high"
                                              "x!2"
                                              "F"
                                              "AA"
                                              "G"
                                              "BB"))
                                            (("2" (propax) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide-all-but (1 -3))
                                (("2"
                                  (lemma
                                   "limit_nonneg"
                                   ("nna" "series(BB)"))
                                  (("1"
                                    (split -1)
                                    (("1"
                                      (rewrite "limit_equiv" -2)
                                      (("1"
                                        (flatten)
                                        (("1"
                                          (assert)
                                          (("1"
                                            (hide -2 -3)
                                            (("1"
                                              (reveal -4)
                                              (("1"
                                                (rewrite "limit_equiv")
                                                nil
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (expand "convergent?")
                                      (("2"
                                        (inst + "l!1")
                                        (("2"
                                          (reveal -2)
                                          (("2" (propax) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (hide-all-but 1)
                                    (("2"
                                      (expand "series")
                                      (("2"
                                        (induct "x1")
                                        (("1"
                                          (expand "sigma")
                                          (("1"
                                            (expand "BB")
                                            (("1" (grind) nil nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (expand "BB")
                                          (("2"
                                            (skosimp)
                                            (("2"
                                              (expand "sigma" 1)
                                              (("2"
                                                (case-replace
                                                 "a!1(1 + j!1) < 0")
                                                (("1" (assertnil nil)
                                                 ("2"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("3"
                                (hide-all-but 1)
                                (("3"
                                  (expand "BB")
                                  (("3" (grind) nil nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (hide-all-but (1 -3))
                              (("2"
                                (lemma
                                 "limit_nonneg"
                                 ("nna" "series(AA)"))
                                (("1"
                                  (reveal -2)
                                  (("1"
                                    (split -2)
                                    (("1"
                                      (rewrite "limit_equiv" -2)
                                      (("1"
                                        (flatten)
                                        (("1" (assertnil nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (expand "convergent?")
                                      (("2" (inst + "l!2"nil nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (hide-all-but 1)
                                  (("2"
                                    (expand "series")
                                    (("2"
                                      (expand "AA")
                                      (("2"
                                        (induct "x1")
                                        (("1" (grind) nil nil)
                                         ("2"
                                          (skosimp)
                                          (("2"
                                            (expand "sigma" 1)
                                            (("2"
                                              (case-replace
                                               "a!1(1 + j!1) < 0")
                                              (("1" (assertnil nil)
                                               ("2" (assertnil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("3" (hide-all-but 1)
                              (("3"
                                (expand "AA")
                                (("3" (grind) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (hide-all-but (-3 1))
                  (("2"
                    (lemma "comparison_test" ("a" "BB" "b" "abs(a!1)"))
                    (("2" (assert)
                      (("2" (hide-all-but 1)
                        (("2" (skosimp)
                          (("2" (expand "BB")
                            (("2" (expand "abs")
                              (("2"
                                (lift-if)
                                (("2"
                                  (expand "abs")
                                  (("2" (propax) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (hide-all-but (-2 1))
                (("2"
                  (lemma "comparison_test" ("b" "abs(a!1)" "a" "AA"))
                  (("2" (assert)
                    (("2" (hide-all-but 1)
                      (("2" (expand "AA") (("2" (grind) nil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (hide-all-but 1)
            (("2" (apply-extensionality :hide? t)
              (("2" (expand "-")
                (("2" (expand "AA")
                  (("2" (expand "BB")
                    (("2" (case-replace "a!1(x!2) < 0")
                      (("1" (assertnil nil) ("2" (assertnil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((sequence type-eq-decl nil sequences nil)
    (< const-decl "bool" reals nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (= const-decl "[T, T -> boolean]" equalities 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)
    (- const-decl "[T -> real]" real_fun_ops "reals/")
    (convergent? const-decl "bool" convergence_sequences "analysis/")
    (series const-decl "sequence[real]" series nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (abs const-decl "sequence[real]" series nil)
    (comparison_test formula-decl nil series nil)
    (AA skolem-const-decl "[nat -> real]" series_aux nil)
    (sigma_minus formula-decl nil sigma "reals/")
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (sigma def-decl "real" sigma "reals/")
    (T_high type-eq-decl nil sigma "reals/")
    (T_low type-eq-decl nil sigma "reals/")
    (<= const-decl "bool" reals nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (unique_limit formula-decl nil convergence_sequences "analysis/")
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (convergence const-decl "bool" convergence_sequences "analysis/")
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (cnv_seq_diff formula-decl nil convergence_ops "analysis/")
    (O const-decl "T3" function_props nil)
    (limit_nonneg formula-decl nil series_aux nil)
    (limit_equiv formula-decl nil convergence_ops "analysis/")
    (int_minus_int_is_int application-judgement "int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (BB skolem-const-decl "[nat -> real]" series_aux nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (bijective? const-decl "bool" functions nil)
    (nnreal type-eq-decl nil real_types nil)
    (nonneg_series_bij formula-decl nil series_aux nil)
    (minus_real_is_real application-judgement "real" reals nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield -> numfield]" number_fields nil))
   shostak))
 (abs_series_bij_conv 0
  (abs_series_bij_conv-1 nil 3322870238
   ("" (skosimp)
    (("" (lemma "convergent_abs" ("a" "a!1"))
      (("" (assert)
        (("" (expand "convergent?" (-1 1))
          (("" (skosimp)
            ((""
              (lemma "abs_series_bij"
               ("a" "a!1" "phi" "phi!1" "x" "l!1"))
              (("" (assert) (("" (inst + "l!1"nil nil)) nil)) nil))
            nil))
          nil))
        nil))
      nil))
    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)
    (convergent_abs formula-decl nil series nil)
    (convergent? const-decl "bool" convergence_sequences "analysis/")
    (bijective? const-decl "bool" functions nil)
    (abs_series_bij formula-decl nil series_aux nil))
   shostak))
 (abs_series_bij_limit_TCC1 0
  (abs_series_bij_limit_TCC1-1 nil 3322870064
   ("" (skosimp)
    (("" (lemma "convergent_abs" ("a" "a!1")) (("" (assertnil nil))
      nil))
    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)
    (convergent_abs formula-decl nil series nil))
   shostak))
 (abs_series_bij_limit_TCC2 0
  (abs_series_bij_limit_TCC2-1 nil 3322870064
   ("" (skosimp)
    (("" (lemma "abs_series_bij_conv" ("a" "a!1" "phi" "phi!1"))
      (("" (assertnil nil)) nil))
    nil)
   ((bijective? const-decl "bool" functions 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)
    (abs_series_bij_conv formula-decl nil series_aux nil))
   shostak))
 (abs_series_bij_limit 0
  (abs_series_bij_limit-2 nil 3462013823
   ("" (skosimp)
    (("" (lemma "abs_series_bij_conv" ("a" "a!1" "phi" "phi!1"))
      (("" (lemma "convergent_abs" ("a" "a!1"))
        (("" (assert)
          (("" (expand "convergent?" (-1 -2))
            (("" (skosimp*)
              ((""
                (lemma "abs_series_bij"
                 ("a" "a!1" "phi" "phi!1" "x" "l!1"))
                (("" (assert)
                  ((""
                    (lemma "unique_limit"
                     ("u" "series(a!1 o phi!1)" "l1" "l!1" "l2" "l!2"))
                    (("" (assert)
                      (("" (rewrite "limit_equiv" -2)
                        (("" (rewrite "limit_equiv" -3)
                          (("" (assertnil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((bijective? const-decl "bool" functions 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)
    (abs_series_bij_conv formula-decl nil series_aux nil)
    (limit_equiv formula-decl nil convergence_ops "analysis/")
    (O const-decl "T3" function_props nil)
    (series const-decl "sequence[real]" series nil)
    (unique_limit formula-decl nil convergence_sequences "analysis/")
    (abs_series_bij formula-decl nil series_aux nil)
    (convergent? const-decl "bool" convergence_sequences "analysis/")
    (convergent_abs formula-decl nil series nil))
   nil)
  (abs_series_bij_limit-1 nil 3322869658
   ("" (skosimp)
    (("" (lemma "abs_series_bij_conv" ("a" "a!1" "phi" "phi!1"))
      (("" (lemma "convergent?_abs" ("a" "a!1"))
        (("" (assert)
          (("" (expand "convergent?" (-1 -2))
            (("" (skosimp*)
              ((""
                (lemma "abs_series_bij"
                 ("a" "a!1" "phi" "phi!1" "x" "l!1"))
                (("" (assert)
                  ((""
                    (lemma "unique_limit"
                     ("u" "series(a!1 o phi!1)" "l1" "l!1" "l2" "l!2"))
                    (("" (assert)
                      (("" (rewrite "limit_equiv" -2)
                        (("" (rewrite "limit_equiv" -3)
                          (("" (assertnil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((limit_equiv formula-decl nil convergence_ops "analysis/")
    (unique_limit formula-decl nil convergence_sequences "analysis/")
    (convergent? const-decl "bool" convergence_sequences "analysis/"))
   shostak)))


Messung V0.5 in Prozent
C=97 H=97 G=96

¤ 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.0.472Bemerkung:  (vorverarbeitet am  2026-04-25) ¤

*Bot Zugriff






Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

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

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.






                                                                                                                                                                                                                                                                                                                                                                                                     


Neuigkeiten

     Aktuelles
     Motto des Tages

Software

     Produkte
     Quellcodebibliothek

Aktivitäten

     Artikel über Sicherheit
     Anleitung zur Aktivierung von SSL

Muße

     Gedichte
     Musik
     Bilder

Jenseits des Üblichen ....

Besucherstatistik

Besucherstatistik

Monitoring

Montastic status badge