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


SSL series_lems.prf

  Interaktion und
PortierbarkeitLisp
 

(series_lems
 (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_lems 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_lems 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_lems nil)
    (series const-decl "sequence[real]" series nil)
    (limit_equiv formula-decl nil convergence_ops "analysis/")
    (zero_tail_series_limit formula-decl nil series_lems 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_lems 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_lems 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_lems 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_lems nil)
    (limit_equiv formula-decl nil convergence_ops "analysis/")
    (series const-decl "sequence[real]" series nil)
    (single_nz_series_limit formula-decl nil series_lems 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"
                                                                (expand
                                                                 "sigma")
                                                                (("1"
                                                                  (assert)
                                                                  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_lems 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_lems nil)
    (y!1 skolem-const-decl "nat" series_lems 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_lems nil)
    (nna!1 skolem-const-decl "sequence[nnreal]" series_lems 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-2 nil 3445686407
   ("" (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_lems nil)
    (j!1 skolem-const-decl "nat" series_lems 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_lems nil)
    (i!1 skolem-const-decl "int" series_lems 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_lems 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_lems nil)
    (MM skolem-const-decl "[[(bijective?[nat, nat]), nat] -> set[nat]]"
     series_lems 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_lems nil)
    (x skolem-const-decl "(fullset[below[1 + j!1]])" series_lems nil)
    (j!1 skolem-const-decl "nat" series_lems 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_lems nil)
    (x!2 skolem-const-decl "(fullset[below[2 + j!1]])" series_lems nil)
    (j!1 skolem-const-decl "nat" series_lems nil)
    (n!1 skolem-const-decl "nat" series_lems 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_lems nil)
    (phi1 skolem-const-decl "[nat -> nat]" series_lems 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))
   nil)
  (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)
                                                                                                        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)
   ((is_finite const-decl "bool" finite_sets nil)
    (increasing? const-decl "bool" real_fun_preds "reals/")
    (sigma_split formula-decl nil sigma "reals/")
    (convergence_cauchy formula-decl nil convergence_sequences
     "analysis/")
    (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/")
    (T_low type-eq-decl nil sigma "reals/")
    (T_high type-eq-decl nil sigma "reals/")
    (sigma def-decl "real" sigma "reals/")
    (sigma_le formula-decl nil sigma "reals/")
    (sigma_zero formula-decl nil sigma "reals/")
    (sigma_0_neg formula-decl nil sigma_nat "reals/")
    (sigma_with formula-decl nil sigma "reals/")
    (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)
    (member const-decl "bool" sets nil)
    (convergence const-decl "bool" convergence_sequences "analysis/")
    (set type-eq-decl nil sets 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_lems 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_lems 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_lems 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_lems nil)
    (convergent? const-decl "bool" convergence_sequences "analysis/")
    (nonneg_series_bij formula-decl nil series_lems 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_lems 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_lems 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_lems 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_lems 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_lems 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-2 nil 3445686459
   ("" (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_lems nil))
   nil)
  (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)
   ((convergent_abs formula-decl nil series 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_lems nil))
   shostak))
 (abs_series_bij_limit 0
  (abs_series_bij_limit-2 nil 3445686483
   ("" (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_lems 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_lems 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_abs formula-decl nil series nil))
   shostak)))


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

¤ 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.703Bemerkung:  (Wie Sie bei der Firma Beratungs- und Dienstleistungen beauftragen können 2026-05-01) ¤

*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