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


Impressum riesz_representation.prf

  Sprache: Lisp
 

(riesz_representation
 (IMP_rs_integral_cont_TCC1 0
  (IMP_rs_integral_cont_TCC1-1 nil 3511191506
   ("" (expand "connected?")
    (("" (skosimp*) (("" (ground) nil nil)) nil)) nil)
   ((real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (connected? const-decl "bool" deriv_domain_def nil))
   nil))
 (IMP_rs_integral_cont_TCC2 0
  (IMP_rs_integral_cont_TCC2-1 nil 3511191506
   ("" (expand "not_one_element?")
    (("" (skosimp*)
      (("" (inst-cp + "a")
        (("" (inst + "b") (("" (grind) nil nil)) nil)) nil))
      nil))
    nil)
   ((/= const-decl "boolean" notequal nil)
    (INTab type-eq-decl nil riesz_interval_funs nil)
    (b formal-const-decl "{bb: real | a < bb}" riesz_representation
     nil)
    (< const-decl "bool" reals nil)
    (a formal-const-decl "real" riesz_representation nil)
    (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (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)
    (not_one_element? const-decl "bool" deriv_domain_def nil))
   nil))
 (integral_norm_bounded_TCC1 0
  (integral_norm_bounded_TCC1-1 nil 3492953409
   ("" (subtype-tcc) nil nil)
   ((real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (integral_norm_bounded_TCC2 0
  (integral_norm_bounded_TCC2-1 nil 3492953409
   ("" (subtype-tcc) nil 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))
   nil))
 (integral_norm_bounded_TCC3 0
  (integral_norm_bounded_TCC3-1 nil 3492953409
   ("" (skolem 1 ("ff" "gg"))
    (("" (flatten)
      (("" (lemma "continuous_implies_bounded[a,b]")
        (("" (inst - "ff")
          (("" (expand "zero_off_int_and_bounded?")
            (("" (ground) nil nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((AND const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (INTab type-eq-decl nil riesz_interval_funs nil)
    (continuous_on_int? const-decl "bool" riesz_interval_funs nil)
    (Continuous_Function type-eq-decl nil riesz_interval_funs nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (continuous_implies_bounded formula-decl nil riesz_interval_funs
     nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (a formal-const-decl "real" riesz_representation nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (< const-decl "bool" reals nil)
    (b formal-const-decl "{bb: real | a < bb}" riesz_representation
     nil))
   nil))
 (integral_norm_bounded 0
  (integral_norm_bounded-1 nil 3492953409
   ("" (skolem 1 ("ff" "gg"))
    (("" (case "NOT integrable?(a,b,gg,ff)")
      (("1" (hide 2)
        (("1" (lemma "RS_integrable_cont_BV")
          (("1" (inst - "a" "b" "ff" "gg")
            (("1" (assert)
              (("1" (typepred "ff")
                (("1" (expand "continuous_on_int?")
                  (("1" (expand "continuous?")
                    (("1" (skosimp*)
                      (("1" (inst - "x!1")
                        (("1" (expand "continuous_at?")
                          (("1" (skosimp*)
                            (("1" (inst - "epsilon!1")
                              (("1"
                                (skosimp*)
                                (("1"
                                  (inst + "delta!1")
                                  (("1"
                                    (skosimp*)
                                    (("1"
                                      (inst - "y!1")
                                      (("1" (assertnil nil)
                                       ("2"
                                        (expand "restrict" +)
                                        (("2"
                                          (expand "Intab")
                                          (("2" (propax) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (expand "restrict" +)
                          (("2" (expand "Intab")
                            (("2" (propax) nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (label "fint" -1)
        (("2" (assert)
          (("2" (name "SS" "integral(a,b,gg,ff)")
            (("2" (label "SSname" -1)
              (("2" (lemma "integral_def")
                (("2" (inst - "a" "b" "ff" "gg" "SS")
                  (("2" (split -)
                    (("1" (flatten)
                      (("1" (hide -2)
                        (("1" (split -)
                          (("1" (label "integrall?" -1)
                            (("1"
                              (case "FORALL (P:partition(a,b),xis:xis?(a,b,P)): abs(Rie_sum(a,b,gg,P,xis,ff)) <= total_variation(a,b,gg)(b)*fun_norm(ff)")
                              (("1"
                                (case
                                 "FORALL (eps:posreal): abs(integral(a, b, gg, ff)) <=
                                                                       total_variation(a, b, gg)(b) * fun_norm(ff)+eps")
                                (("1"
                                  (inst
                                   -
                                   "(abs(integral(a, b, gg, ff)) -
                                             total_variation(a, b, gg)(b) * fun_norm(ff))/10")
                                  (("1" (assertnil nil))
                                  nil)
                                 ("2"
                                  (hide 2)
                                  (("2"
                                    (expand "integral?")
                                    (("2"
                                      (skeep)
                                      (("2"
                                        (inst "integrall?" "eps/10")
                                        (("2"
                                          (skosimp*)
                                          (("2"
                                            (lemma "partition_exists")
                                            (("2"
                                              (inst
                                               -
                                               "a"
                                               "b"
                                               "delta!1")
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (skosimp*)
                                                  (("2"
                                                    (name
                                                     "xis"
                                                     "gen_xis(a,b,P!1)")
                                                    (("2"
                                                      (inst
                                                       -
                                                       "P!1"
                                                       "xis")
                                                      (("2"
                                                        (inst - "P!1")
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (inst
                                                             -
                                                             "Rie_sum(a,b,gg,P!1,xis,ff)")
                                                            (("1"
                                                              (grind
                                                               :exclude
                                                               ("gen_xis"
                                                                "width"
                                                                "Rie_sum"
                                                                "total_variation"
                                                                "integral"
                                                                "integrable?"))
                                                              nil
                                                              nil)
                                                             ("2"
                                                              (lemma
                                                               "Riemann?_Rie")
                                                              (("2"
                                                                (inst
                                                                 -
                                                                 "a"
                                                                 "b"
                                                                 "ff"
                                                                 "gg")
                                                                (("2"
                                                                  (split
                                                                   -)
                                                                  (("1"
                                                                    (inst
                                                                     -
                                                                     "P!1"
                                                                     "xis")
                                                                    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"
                                  (skeep)
                                  (("2"
                                    (expand "Rie_sum")
                                    (("2"
                                      (lemma
                                       "sigma_abs[below(P`length-1)]")
                                      (("2"
                                        (inst?)
                                        (("2"
                                          (case
                                           "sigma(0, P`length - 2,
                                             LAMBDA (n_1: below(P`length - 1)):
                                               abs(ff(xis`seq(n_1)) * gg(P`seq(1 + n_1)) -
                                                    ff(xis`seq(n_1)) * gg(P`seq(n_1)))) <= total_variation(a, b, gg)(b) * fun_norm(ff)")
                                          (("1" (assertnil nil)
                                           ("2"
                                            (hide 2)
                                            (("2"
                                              (hide -1)
                                              (("2"
                                                (typepred
                                                 "total_variation(a,b,gg)(b)")
                                                (("2"
                                                  (assert)
                                                  (("2"
                                                    (inst - "P")
                                                    (("2"
                                                      (case
                                                       "sigma(0, P`length - 2,
                                                 LAMBDA (n_1: below(P`length - 1)):
                                                   abs(ff(xis`seq(n_1)) * gg(P`seq(1 + n_1)) -
                                                        ff(xis`seq(n_1)) * gg(P`seq(n_1)))) <= variation_on(a, b, P)(gg) * fun_norm(ff)")
                                                      (("1"
                                                        (mult-by
                                                         -4
                                                         "fun_norm[a,b](ff)")
                                                        (("1"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (hide 2)
                                                        (("2"
                                                          (expand
                                                           "variation_on")
                                                          (("2"
                                                            (lemma
                                                             "sigma_scal[below(P`length-1)]")
                                                            (("2"
                                                              (inst
                                                               -
                                                               "LAMBDA (n: below(P`length - 1)):
                                            abs(gg(P`seq(1 + n)) - gg(P`seq(n)))"
                                                               "fun_norm[a,b](ff)"
                                                               "P`length-2"
                                                               "0")
                                                              (("2"
                                                                (replace
                                                                 -1
                                                                 :dir
                                                                 rl)
                                                                (("2"
                                                                  (hide
                                                                   -1)
                                                                  (("2"
                                                                    (rewrite
                                                                     "sigma_le")
                                                                    (("2"
                                                                      (hide
                                                                       2)
                                                                      (("2"
                                                                        (skeep)
                                                                        (("2"
                                                                          (typepred
                                                                           "n")
                                                                          (("2"
                                                                            (lemma
                                                                             "abs_mult")
                                                                            (("2"
                                                                              (inst
                                                                               -
                                                                               "ff(xis`seq(n))"
                                                                               "gg(P`seq(1 + n)) -gg(P`seq(n))")
                                                                              (("2"
                                                                                (replace
                                                                                 -1)
                                                                                (("2"
                                                                                  (case
                                                                                   "abs(ff(xis`seq(n))) <= fun_norm(ff)")
                                                                                  (("1"
                                                                                    (mult-by
                                                                                     -1
                                                                                     "abs(gg(P`seq(1 + n)) - gg(P`seq(n)))")
                                                                                    nil
                                                                                    nil)
                                                                                   ("2"
                                                                                    (typepred
                                                                                     "fun_norm(ff)")
                                                                                    (("2"
                                                                                      (inst
                                                                                       -
                                                                                       "xis`seq(n)")
                                                                                      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" (propax) nil nil)
                           ("3" (propax) nil nil))
                          nil))
                        nil))
                      nil)
                     ("2" (ground) nil nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("3" (assert)
        (("3" (typepred "b") (("3" (assertnil nil)) nil)) nil)
       ("4" (assertnil nil))
      nil))
    nil)
   ((Continuous_Function type-eq-decl nil riesz_interval_funs nil)
    (continuous_on_int? const-decl "bool" riesz_interval_funs nil)
    (bounded_variation? const-decl "bool" bounded_variation nil)
    (integrable? const-decl "bool" rs_integral_def nil)
    (INTab type-eq-decl nil riesz_interval_funs nil)
    (b formal-const-decl "{bb: real | a < bb}" riesz_representation
     nil)
    (< const-decl "bool" reals nil)
    (a formal-const-decl "real" riesz_representation nil)
    (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (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)
    (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)
    (RS_integrable_cont_BV formula-decl nil rs_integral_cont nil)
    (continuous_at? const-decl "bool" continuity_ms_def nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (>= const-decl "bool" reals nil)
    (y!1 skolem-const-decl "(LAMBDA (x: INTab[a, b]): TRUE)"
     riesz_representation nil)
    (member const-decl "bool" sets nil)
    (x!1 skolem-const-decl "(LAMBDA (x: INTab[a, b]): TRUE)"
     riesz_representation nil)
    (TRUE const-decl "bool" booleans nil)
    (Intab const-decl "set[real]" riesz_interval_funs nil)
    (set type-eq-decl nil sets nil)
    (restrict const-decl "R" restrict nil)
    (continuous? const-decl "bool" continuity_ms_def nil)
    (fun_norm const-decl "{M: nnreal |
         (FORALL (x): abs(f(x)) <= M) AND
          (FORALL (M1: real): M1 < M IMPLIES (EXISTS (x): abs(f(x)) > M1))}"
     riesz_interval_funs nil)
    (bounded_on_int? const-decl "bool" riesz_interval_funs nil)
    (total_variation const-decl "{M: nnreal |
         (x = a IMPLIES M = 0) AND
          (x > a IMPLIES
            (FORALL (P: partition(a, x)): variation_on(a, x, P)(f) <= M))
           AND
           (FORALL (M1: nnreal):
              M1 < M IMPLIES
               (EXISTS (P: partition(a, x)):
                  variation_on(a, x, P)(f) > M1))}" bounded_variation
     nil)
    (variation_on const-decl "nnreal" bounded_variation nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (nnreal type-eq-decl nil real_types nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (Rie_sum const-decl "real" rs_integral_def nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (xis? type-eq-decl nil rs_integral_def nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (partition type-eq-decl nil rs_partition nil)
    (below type-eq-decl nil naturalnumbers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (increasing? const-decl "bool" sort_fseq "structures/")
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (fseq type-eq-decl nil fseqs "structures/")
    (barray type-eq-decl nil fseqs "structures/")
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (nnreal_times_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (Riemann?_Rie formula-decl nil rs_integral_def nil)
    (minus_real_is_real application-judgement "real" reals nil)
    (xis skolem-const-decl "xis?[INTab](a, b, P!1)"
     riesz_representation nil)
    (ff skolem-const-decl "Continuous_Function[a, b]"
     riesz_representation nil)
    (gg skolem-const-decl "(bounded_variation?(a, b))"
     riesz_representation nil)
    (P!1 skolem-const-decl "partition[INTab](a, b)"
     riesz_representation nil)
    (Riemann_sum? const-decl "bool" rs_integral_def nil)
    (gen_xis const-decl "xis?(a, b, P)" rs_integral_def nil)
    (partition_exists formula-decl nil rs_partition nil)
    (posreal_div_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/= const-decl "boolean" notequal nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (nnreal_plus_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (sigma_abs formula-decl nil sigma "reals/")
    (sigma def-decl "real" sigma "reals/")
    (sigma_nnreal application-judgement "nnreal" sigma_below "reals/")
    (both_sides_times_pos_le1_imp formula-decl nil extra_real_props
     nil)
    (subrange type-eq-decl nil integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (abs_mult formula-decl nil real_props nil)
    (sigma_le formula-decl nil sigma "reals/")
    (sigma_scal formula-decl nil sigma "reals/")
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (T_high type-eq-decl nil sigma "reals/")
    (T_low type-eq-decl nil sigma "reals/")
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (integral_def formula-decl nil rs_integral_def nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (integral? const-decl "bool" rs_integral_def nil)
    (integral const-decl "{S: real | integral?(a, b, gg, ff, S)}"
     rs_integral_def nil))
   shostak))
 (fun_to_op_TCC1 0
  (fun_to_op_TCC1-1 nil 3492949849
   ("" (skolem 1 ("gg" "ff"))
    (("" (lemma "RS_integrable_cont_BV")
      (("" (inst - "a" "b" "ff" "gg")
        (("" (assert)
          (("" (hide 2)
            (("" (typepred "ff")
              (("" (expand "continuous_on_int?")
                (("" (expand "restrict")
                  (("" (expand "continuous?")
                    (("" (skosimp*)
                      (("" (inst - "x!1")
                        (("1" (expand "continuous_at?")
                          (("1" (skosimp*)
                            (("1" (inst - "epsilon!1")
                              (("1"
                                (skosimp*)
                                (("1"
                                  (inst + "delta!1")
                                  (("1"
                                    (skosimp*)
                                    (("1"
                                      (inst - "y!1")
                                      (("1" (assertnil nil)
                                       ("2"
                                        (expand "Intab")
                                        (("2" (propax) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (expand "Intab") (("2" (propax) nil nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((INTab type-eq-decl nil riesz_interval_funs nil)
    (b formal-const-decl "{bb: real | a < bb}" riesz_representation
     nil)
    (< const-decl "bool" reals nil)
    (a formal-const-decl "real" riesz_representation nil)
    (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (RS_integrable_cont_BV formula-decl nil rs_integral_cont nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (restrict const-decl "R" restrict nil)
    (continuous_at? const-decl "bool" continuity_ms_def nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (>= const-decl "bool" reals nil)
    (y!1 skolem-const-decl "(LAMBDA (x: INTab[a, b]): TRUE)"
     riesz_representation nil)
    (member const-decl "bool" sets nil)
    (x!1 skolem-const-decl "(LAMBDA (x: INTab[a, b]): TRUE)"
     riesz_representation nil)
    (TRUE const-decl "bool" booleans nil)
    (Intab const-decl "set[real]" riesz_interval_funs nil)
    (set type-eq-decl nil sets nil)
    (continuous? const-decl "bool" continuity_ms_def nil)
    (bounded_variation? const-decl "bool" bounded_variation nil)
    (Continuous_Function type-eq-decl nil riesz_interval_funs nil)
    (continuous_on_int? const-decl "bool" riesz_interval_funs nil))
   nil))
 (fun_to_op_TCC2 0
  (fun_to_op_TCC2-1 nil 3492953553
   ("" (skolem 1 "gg")
    (("" (expand "bounded_linear_operator?")
      (("" (split)
        (("1" (expand "bounded_op?")
          (("1" (inst + "total_variation(a,b,gg)(b)")
            (("1" (skolem 1 "f")
              (("1" (lemma "integral_norm_bounded")
                (("1" (inst - "f" "gg") (("1" (assertnil nil)) nil))
                nil))
              nil)
             ("2" (typepred "b") (("2" (assertnil nil)) nil)
             ("3" (assertnil nil) ("4" (assertnil nil))
            nil))
          nil)
         ("2" (expand "linear_op?")
          (("2" (split)
            (("1" (expand "additive_op?")
              (("1" (skolem 1 ("ff" "hh"))
                (("1" (lemma "integral_sum")
                  (("1" (inst?)
                    (("1" (assert)
                      (("1" (split -)
                        (("1" (expand "+") (("1" (assertnil nil))
                          nil)
                         ("2" (hide 2)
                          (("2" (typepred "ff")
                            (("2" (lemma "RS_integrable_cont_BV")
                              (("2"
                                (inst?)
                                (("2"
                                  (assert)
                                  (("2"
                                    (hide 2)
                                    (("2"
                                      (expand "continuous_on_int?")
                                      (("2"
                                        (expand "continuous?")
                                        (("2"
                                          (skosimp*)
                                          (("2"
                                            (inst - "x!1")
                                            (("1"
                                              (expand "continuous_at?")
                                              (("1"
                                                (skosimp*)
                                                (("1"
                                                  (inst - "epsilon!1")
                                                  (("1"
                                                    (skosimp*)
                                                    (("1"
                                                      (inst
                                                       +
                                                       "delta!1")
                                                      (("1"
                                                        (skosimp*)
                                                        (("1"
                                                          (inst
                                                           -
                                                           "y!1")
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil)
                                                           ("2"
                                                            (expand
                                                             "restrict")
                                                            (("2"
                                                              (expand
                                                               "Intab")
                                                              (("2"
                                                                (propax)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (expand "restrict")
                                              (("2"
                                                (expand "Intab")
                                                (("2"
                                                  (propax)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("3" (hide 2)
                          (("3" (lemma "RS_integrable_cont_BV")
                            (("3" (inst?)
                              (("3"
                                (assert)
                                (("3"
                                  (hide 2)
                                  (("3"
                                    (typepred "hh")
                                    (("3"
                                      (expand "continuous_on_int?")
                                      (("3"
                                        (expand "continuous?")
                                        (("3"
                                          (skosimp*)
                                          (("3"
                                            (inst - "x!1")
                                            (("1"
                                              (expand "continuous_at?")
                                              (("1"
                                                (skosimp*)
                                                (("1"
                                                  (inst - "epsilon!1")
                                                  (("1"
                                                    (skosimp*)
                                                    (("1"
                                                      (inst
                                                       +
                                                       "delta!1")
                                                      (("1"
                                                        (skosimp*)
                                                        (("1"
                                                          (inst
                                                           -
                                                           "y!1")
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil)
                                                           ("2"
                                                            (expand
                                                             "restrict")
                                                            (("2"
                                                              (expand
                                                               "Intab")
                                                              (("2"
                                                                (propax)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (expand "restrict")
                                              (("2"
                                                (expand "Intab")
                                                (("2"
                                                  (propax)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (expand "const_inv_op?")
              (("2" (skolem 1 ("f" "c"))
                (("2" (lemma "integral_scal")
                  (("2" (inst?)
                    (("2" (assert)
                      (("2" (hide 2)
                        (("2" (lemma "RS_integrable_cont_BV")
                          (("2" (inst?)
                            (("2" (assert)
                              (("2"
                                (hide 2)
                                (("2"
                                  (typepred "f")
                                  (("2"
                                    (expand "continuous_on_int?")
                                    (("2"
                                      (expand "continuous?")
                                      (("2"
                                        (skosimp*)
                                        (("2"
                                          (inst - "x!1")
                                          (("1"
                                            (expand "continuous_at?")
                                            (("1"
                                              (skosimp*)
                                              (("1"
                                                (inst - "epsilon!1")
                                                (("1"
                                                  (skosimp*)
                                                  (("1"
                                                    (inst + "delta!1")
                                                    (("1"
                                                      (skosimp*)
                                                      (("1"
                                                        (inst - "y!1")
                                                        (("1"
                                                          (assert)
                                                          nil
                                                          nil)
                                                         ("2"
                                                          (expand
                                                           "restrict")
                                                          (("2"
                                                            (expand
                                                             "Intab")
                                                            (("2"
                                                              (propax)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (expand "restrict")
                                            (("2"
                                              (expand "Intab")
                                              (("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)
   ((bounded_linear_operator? const-decl "bool"
     riesz_bounded_functionals nil)
    (linear_op? const-decl "bool" riesz_linear_functionals nil)
    (const_inv_op? const-decl "bool" riesz_linear_functionals nil)
    (integral_scal formula-decl nil rs_integral_prep nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (x!1 skolem-const-decl "(LAMBDA (x: INTab[a, b]): TRUE)"
     riesz_representation nil)
    (y!1 skolem-const-decl "(LAMBDA (x: INTab[a, b]): TRUE)"
     riesz_representation nil)
    (additive_op? const-decl "bool" riesz_linear_functionals nil)
    (integral_sum formula-decl nil rs_integral_prep nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (y!1 skolem-const-decl "(LAMBDA (x: INTab[a, b]): TRUE)"
     riesz_representation nil)
    (x!1 skolem-const-decl "(LAMBDA (x: INTab[a, b]): TRUE)"
     riesz_representation nil)
    (RS_integrable_cont_BV formula-decl nil rs_integral_cont nil)
    (continuous_at? const-decl "bool" continuity_ms_def nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (y!1 skolem-const-decl "(LAMBDA (x: INTab[a, b]): TRUE)"
     riesz_representation nil)
    (member const-decl "bool" sets nil)
    (x!1 skolem-const-decl "(LAMBDA (x: INTab[a, b]): TRUE)"
     riesz_representation nil)
    (TRUE const-decl "bool" booleans nil)
    (Intab const-decl "set[real]" riesz_interval_funs nil)
    (set type-eq-decl nil sets nil)
    (continuous? const-decl "bool" continuity_ms_def nil)
    (+ const-decl "[T -> real]" real_fun_ops "reals/")
    (bounded_op? const-decl "bool" riesz_bounded_functionals nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (Continuous_Function type-eq-decl nil riesz_interval_funs nil)
    (continuous_on_int? const-decl "bool" riesz_interval_funs nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (nnreal_times_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (integral_norm_bounded formula-decl nil riesz_representation nil)
    (total_variation const-decl "{M: nnreal |
         (x = a IMPLIES M = 0) AND
          (x > a IMPLIES
            (FORALL (P: partition(a, x)): variation_on(a, x, P)(f) <= M))
           AND
           (FORALL (M1: nnreal):
              M1 < M IMPLIES
               (EXISTS (P: partition(a, x)):
                  variation_on(a, x, P)(f) > M1))}" bounded_variation
     nil)
    (variation_on const-decl "nnreal" bounded_variation nil)
    (partition type-eq-decl nil rs_partition nil)
    (below type-eq-decl nil naturalnumbers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (increasing? const-decl "bool" sort_fseq "structures/")
    (restrict const-decl "R" restrict nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (fseq type-eq-decl nil fseqs "structures/")
    (barray type-eq-decl nil fseqs "structures/")
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (> const-decl "bool" reals nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (bounded_variation? const-decl "bool" bounded_variation nil)
    (INTab type-eq-decl nil riesz_interval_funs nil)
    (nnreal type-eq-decl nil real_types nil)
    (>= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (<= const-decl "bool" reals nil)
    (a formal-const-decl "real" riesz_representation nil)
    (< const-decl "bool" reals nil)
    (b formal-const-decl "{bb: real | a < bb}" riesz_representation
     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))
   nil))
 (fun_to_op_bound_TCC1 0
  (fun_to_op_bound_TCC1-1 nil 3492957266 ("" (subtype-tcc) nil nil)
   ((real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (fun_to_op_bound 0
  (fun_to_op_bound-1 nil 3492957266
   ("" (skolem 1 ("ff" "gg"))
    (("" (lemma "integral_norm_bounded")
      (("" (expand "fun_to_op")
        (("" (inst - "ff" "gg") (("" (assertnil nil)) nil)) nil))
      nil))
    nil)
   ((integral_norm_bounded formula-decl nil riesz_representation nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (a formal-const-decl "real" riesz_representation nil)
    (< const-decl "bool" reals nil)
    (b formal-const-decl "{bb: real | a < bb}" riesz_representation
     nil)
    (INTab type-eq-decl nil riesz_interval_funs nil)
    (continuous_on_int? const-decl "bool" riesz_interval_funs nil)
    (Continuous_Function type-eq-decl nil riesz_interval_funs nil)
    (bounded_variation? const-decl "bool" bounded_variation nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (nnreal_times_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (fun_to_op const-decl "C_Bounded_Linear_Operator"
     riesz_representation nil))
   shostak))
 (char_fun_minus 0
  (char_fun_minus-1 nil 3492957695
   ("" (skeep)
    (("" (expand "-")
      (("" (expand "char_fun")
        (("" (decompose-equality) (("" (grind) nil nil)) nil)) nil))
      nil))
    nil)
   ((- const-decl "[T -> real]" real_fun_ops "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)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (INTab type-eq-decl nil riesz_interval_funs nil)
    (b formal-const-decl "{bb: real | a < bb}" riesz_representation
     nil)
    (< const-decl "bool" reals nil)
    (a formal-const-decl "real" riesz_representation nil)
    (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (int_times_even_is_even application-judgement "even_int" integers
     nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (char_fun const-decl "nnreal" riesz_representation nil))
   shostak))
 (step_approx_TCC1 0
  (step_approx_TCC1-1 nil 3492959104 ("" (subtype-tcc) nil nilnil
   nil))
 (step_approx_TCC2 0
  (step_approx_TCC2-1 nil 3492959104 ("" (subtype-tcc) nil nilnil
   nil))
 (step_approx_TCC3 0
  (step_approx_TCC3-1 nil 3492959104 ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (> const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (a formal-const-decl "real" riesz_representation nil)
    (< const-decl "bool" reals nil)
    (b formal-const-decl "{bb: real | a < bb}" riesz_representation
     nil)
    (INTab type-eq-decl nil riesz_interval_funs nil)
    (barray type-eq-decl nil fseqs "structures/")
    (fseq type-eq-decl nil fseqs "structures/")
    (= const-decl "[T, T -> boolean]" equalities nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (restrict const-decl "R" restrict nil)
    (increasing? const-decl "bool" sort_fseq "structures/")
    (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)
    (>= const-decl "bool" reals nil)
    (below type-eq-decl nil naturalnumbers nil)
    (partition type-eq-decl nil rs_partition nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (xis? type-eq-decl nil rs_integral_def nil)
    (bounded_on_int? const-decl "bool" riesz_interval_funs nil)
    (integer nonempty-type-from-decl nil integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   nil))
 (step_approx_TCC4 0
  (step_approx_TCC4-1 nil 3492959104
   ("" (skeep)
    (("" (typepred "fr")
      (("" (expand "bounded_on_int?")
        (("" (skosimp*)
          (("" (inst + "M!1*(P`length+2)")
            (("" (skosimp*)
              ((""
                (case "FORALL (nnn:below(P`length-1)): abs(sigma[below(P`length - 1)]
                     (0, nnn,
                      LAMBDA (n: below(P`length - 1)):
                        fr(xis`seq(n)) * char_fun(P`seq(n), P`seq(1 + n))(x!1)))
              <= M!1 * (nnn+4)")
                (("1" (inst?) (("1" (assertnil nil)) nil)
                 ("2" (hide 2)
                  (("2" (induct "nnn")
                    (("1" (flatten)
                      (("1" (expand "sigma")
                        (("1" (expand "sigma")
                          (("1" (inst - "xis`seq(0)")
                            (("1" (expand "char_fun")
                              (("1"
                                (lift-if)
                                (("1" (ground) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (skolem 1 "nnn")
                      (("2" (flatten)
                        (("2" (expand "sigma" +)
                          (("2" (inst - "xis`seq(1+nnn)")
                            (("2" (grind :exclude "sigma"nil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((bounded_on_int? const-decl "bool" riesz_interval_funs nil)
    (INTab type-eq-decl nil riesz_interval_funs nil)
    (b formal-const-decl "{bb: real | a < bb}" riesz_representation
     nil)
    (< const-decl "bool" reals nil)
    (a formal-const-decl "real" riesz_representation nil)
    (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (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)
    (minus_real_is_real application-judgement "real" reals nil)
    (nnreal_plus_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (abs_nat formula-decl nil abs_lems "reals/")
    (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)
    (below_induction formula-decl nil bounded_nat_inductions nil)
    (pred type-eq-decl nil defined_types nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (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/")
    (xis? type-eq-decl nil rs_integral_def nil)
    (char_fun const-decl "nnreal" riesz_representation nil)
    (partition type-eq-decl nil rs_partition nil)
    (below type-eq-decl nil naturalnumbers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (increasing? const-decl "bool" sort_fseq "structures/")
    (restrict const-decl "R" restrict nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (> const-decl "bool" reals nil)
    (fseq type-eq-decl nil fseqs "structures/")
    (barray type-eq-decl nil fseqs "structures/")
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (nnreal type-eq-decl nil real_types nil)
    (>= const-decl "bool" reals nil)
    (nnreal_times_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil))
   nil))
 (step_approx_def 0
  (step_approx_def-1 nil 3492960304
   ("" (skeep)
    (("" (typepred "f")
      (("" (expand "continuous_on_int?")
        ((""
          (case "uniformly_continuous?[INTab,real_dist,real,real_dist](f,Intab)")
          (("1" (expand "uniformly_continuous?")
            (("1" (inst - "eps")
              (("1" (skosimp*)
                (("1" (inst + "delta!1")
                  (("1" (skeep)
                    (("1" (label "Pwidth" -4)
                      (("1" (label "Pinc" -3)
                        (("1" (label "funif" -1)
                          (("1" (hide -2)
                            (("1" (skosimp*)
                              (("1"
                                (lemma "part_in")
                                (("1"
                                  (case
                                   "FORALL (x: INTab, P: partition(a, b)):
                                                     strictly_increasing?(P) IMPLIES
                                                      (EXISTS (ii: below(P`length - 1)):
                                                         P`seq(ii) <= x AND x <= P`seq(ii + 1) AND
                                                         char_fun(P`seq(ii),P`seq(ii+1))(x) = 1)")
                                  (("1"
                                    (hide -2)
                                    (("1"
                                      (inst - "x!1" "P")
                                      (("1"
                                        (assert)
                                        (("1"
                                          (skosimp*)
                                          (("1"
                                            (case
                                             "step_approx(P,xis)(f)(x!1) = f(xis`seq(ii!1))")
                                            (("1"
                                              (inst
                                               "funif"
                                               "x!1"
                                               "xis`seq(ii!1)")
                                              (("1"
                                                (expand "real_dist")
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (hide 2)
                                                    (("1"
                                                      (hide -1)
                                                      (("1"
                                                        (hide "Pinc")
                                                        (("1"
                                                          (case
                                                           "P`seq(1+ii!1)-P`seq(ii!1) < delta!1")
                                                          (("1"
                                                            (hide
                                                             "Pwidth")
                                                            (("1"
                                                              (typepred
                                                               "xis")
                                                              (("1"
                                                                (inst
                                                                 -
                                                                 "ii!1")
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (grind
                                                                     :exclude
                                                                     ("char_fun"))
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (lemma
                                                             "width_lem")
                                                            (("2"
                                                              (inst
                                                               -
                                                               "a"
                                                               "b"
                                                               "P"
                                                               "ii!1")
                                                              (("2"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (expand "restrict")
                                                (("2"
                                                  (expand "Intab")
                                                  (("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil)
                                               ("3"
                                                (expand "restrict")
                                                (("3"
                                                  (expand "Intab")
                                                  (("3"
                                                    (propax)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (hide 2)
                                              (("2"
                                                (expand "step_approx")
                                                (("2"
                                                  (lemma
                                                   "sigma_split[below(P`length-1)]")
                                                  (("2"
                                                    (inst
                                                     -
                                                     "LAMBDA (n: below(P`length - 1)):
                                                               f(xis`seq(n)) * char_fun(P`seq(n), P`seq(1 + n))(x!1)"
                                                     "P`length-2"
                                                     "0"
                                                     "ii!1")
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (replace -1)
                                                        (("2"
                                                          (hide -1)
                                                          (("2"
                                                            (lemma
                                                             "sigma_split[below(P`length-1)]")
                                                            (("2"
                                                              (inst
                                                               -
                                                               "LAMBDA (n: below(P`length - 1)):
                                                                         f(xis`seq(n)) * char_fun(P`seq(n), P`seq(1 + n))(x!1)"
                                                               "ii!1"
                                                               "0"
                                                               "ii!1-1")
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (replace
                                                                   -1)
                                                                  (("2"
                                                                    (hide
                                                                     -1)
                                                                    (("2"
                                                                      (expand
                                                                       "sigma"
                                                                       +
                                                                       2)
                                                                      (("2"
                                                                        (expand
                                                                         "sigma"
                                                                         +
                                                                         3)
                                                                        (("2"
                                                                          (case
                                                                           "sigma(0, ii!1 - 1,
                                                                                                           LAMBDA (n: below(P`length - 1)):
                                                                                                             f(xis`seq(n)) * char_fun(P`seq(n), P`seq(1 + n))(x!1)) = 0 AND sigma(1 + ii!1, P`length - 2,
                                                                                                            LAMBDA (n: below(P`length - 1)):
                                                                                                              f(xis`seq(n)) * char_fun(P`seq(n), P`seq(1 + n))(x!1)) = 0")
                                                                          (("1"
                                                                            (flatten)
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (hide
                                                                             2)
                                                                            (("2"
                                                                              (split)
                                                                              (("1"
                                                                                (rewrite
                                                                                 "sigma_restrict_eq_0")
                                                                                (("1"
                                                                                  (hide
                                                                                   2)
                                                                                  (("1"
                                                                                    (skolem
                                                                                     1
                                                                                     "jj")
                                                                                    (("1"
                                                                                      (case
                                                                                       "char_fun(P`seq(jj), P`seq(1 + jj))(x!1) = 0")
                                                                                      (("1"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil)
                                                                                       ("2"
                                                                                        (hide
                                                                                         2)
                                                                                        (("2"
                                                                                          (typepred
                                                                                           "jj")
                                                                                          (("2"
                                                                                            (expand
                                                                                             "strictly_increasing?")
                                                                                            (("2"
                                                                                              (inst-cp
                                                                                               "Pinc"
                                                                                               "jj"
                                                                                               "1+jj")
                                                                                              (("2"
                                                                                                (inst
                                                                                                 "Pinc"
                                                                                                 "ii!1"
                                                                                                 "ii!1+1")
                                                                                                (("2"
                                                                                                  (assert)
                                                                                                  (("2"
                                                                                                    (typepred
                                                                                                     "P")
                                                                                                    (("2"
                                                                                                      (expand
                                                                                                       "increasing?")
                                                                                                      (("2"
                                                                                                        (inst
                                                                                                         -
                                                                                                         "1+jj"
                                                                                                         "ii!1")
                                                                                                        (("2"
                                                                                                          (assert)
                                                                                                          (("2"
                                                                                                            (expand
                                                                                                             "char_fun")
                                                                                                            (("2"
                                                                                                              (lift-if)
                                                                                                              (("2"
                                                                                                                (ground)
                                                                                                                nil
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (rewrite
                                                                                 "sigma_restrict_eq_0")
                                                                                (("2"
                                                                                  (hide
                                                                                   2)
                                                                                  (("2"
                                                                                    (skolem
                                                                                     1
                                                                                     "jj")
                                                                                    (("2"
                                                                                      (expand
                                                                                       "strictly_increasing?")
                                                                                      (("2"
                                                                                        (inst-cp
                                                                                         "Pinc"
                                                                                         "jj"
                                                                                         "1+jj")
                                                                                        (("2"
                                                                                          (inst
                                                                                           "Pinc"
                                                                                           "ii!1"
                                                                                           "ii!1+1")
                                                                                          (("2"
                                                                                            (assert)
                                                                                            (("2"
                                                                                              (typepred
                                                                                               "P")
                                                                                              (("2"
                                                                                                (expand
                                                                                                 "increasing?")
                                                                                                (("2"
                                                                                                  (inst
                                                                                                   -
                                                                                                   "ii!1+1"
                                                                                                   "jj")
                                                                                                  (("2"
                                                                                                    (assert)
                                                                                                    (("2"
                                                                                                      (expand
                                                                                                       "char_fun")
                                                                                                      (("2"
                                                                                                        (lift-if)
                                                                                                        (("2"
                                                                                                          (ground)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (hide 2)
                                    (("2"
                                      (hide
                                       ("funif" "Pinc" "Pwidth" 2))
                                      (("2"
                                        (skolem 1 ("yy" "PP"))
                                        (("2"
                                          (flatten)
                                          (("2"
                                            (inst-cp
                                             -
                                             "a"
                                             "b"
                                             "yy"
                                             "PP")
                                            (("2"
                                              (assert)
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (inst-cp
                                                   -
                                                   "a"
                                                   "b"
                                                   "yy"
                                                   "PP")
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (skosimp*)
                                                      (("2"
                                                        (case
                                                         "yy = PP`seq(1+ii!1)")
                                                        (("1"
                                                          (case
                                                           "PP`seq(1+ii!1) = b")
                                                          (("1"
                                                            (inst
                                                             +
                                                             "ii!1")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (expand
                                                                 "char_fun")
                                                                (("1"
                                                                  (propax)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (inst
                                                             +
                                                             "ii!1+1")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (typepred
                                                                 "PP")
                                                                (("1"
                                                                  (expand
                                                                   "increasing?")
                                                                  (("1"
                                                                    (inst
                                                                     -
                                                                     "1+ii!1"
                                                                     "2+ii!1")
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (expand
                                                                         "strictly_increasing?")
                                                                        (("1"
                                                                          (inst
                                                                           -
                                                                           "1+ii!1"
                                                                           "2+ii!1")
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (expand
                                                                               "char_fun")
                                                                              (("1"
                                                                                (propax)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (typepred
                                                               "PP")
                                                              (("2"
                                                                (inst
                                                                 -
                                                                 "2+ii!1")
                                                                (("1"
                                                                  (ground)
                                                                  nil
                                                                  nil)
                                                                 ("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (assert)
                                                          (("2"
                                                            (inst
                                                             -
                                                             "a"
                                                             "b"
                                                             "yy"
                                                             "PP")
                                                            (("2"
                                                              (assert)
                                                              (("2"
                                                                (skosimp*)
                                                                (("2"
                                                                  (inst
                                                                   +
                                                                   "ii!1")
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (expand
                                                                       "char_fun")
                                                                      (("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" (lemma "Heine[real,real_dist,real,real_dist]")
              (("2"
                (name "ff"
                      "LAMBDA (xy:real): IF Intab(xy) THEN f(xy) ELSE 0 ENDIF")
                (("1" (inst - "Intab" "ff")
                  (("1" (assert)
                    (("1" (split -)
                      (("1" (hide-all-but (-1 1))
                        (("1" (expand "uniformly_continuous?")
                          (("1" (skosimp*)
                            (("1" (inst - "epsilon!1")
                              (("1"
                                (skosimp*)
                                (("1"
                                  (inst + "delta!1")
                                  (("1"
                                    (skosimp*)
                                    (("1"
                                      (inst - "x!1" "p!1")
                                      (("1"
                                        (assert)
                                        (("1"
                                          (expand "ff")
                                          (("1"
                                            (case
                                             "Intab(x!1) AND Intab(p!1)")
                                            (("1"
                                              (flatten)
                                              (("1" (assertnil nil))
                                              nil)
                                             ("2"
                                              (expand "Intab")
                                              (("2" (propax) nil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (expand "Intab")
                                        (("2" (propax) nil nil))
                                        nil)
                                       ("3"
                                        (expand "Intab")
                                        (("3" (propax) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (hide 2)
                        (("2" (hide -1)
                          (("2" (expand "continuous?")
                            (("2" (skosimp*)
                              (("2"
                                (inst - "x!1")
                                (("1"
                                  (expand "continuous_at?")
                                  (("1"
                                    (skosimp*)
                                    (("1"
                                      (inst - "epsilon!1")
                                      (("1"
                                        (skosimp*)
                                        (("1"
                                          (inst + "delta!1")
                                          (("1"
                                            (skosimp*)
                                            (("1"
                                              (inst - "y!1")
                                              (("1"
                                                (expand "member")
                                                (("1"
                                                  (expand "ball")
                                                  (("1"
                                                    (expand "ff")
                                                    (("1"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (assert)
                                                (("2"
                                                  (typepred "y!1")
                                                  (("2"
                                                    (expand "Intab")
                                                    (("2"
                                                      (flatten)
                                                      (("2"
                                                        (assert)
                                                        (("2"
                                                          (expand
                                                           "restrict")
                                                          (("2"
                                                            (propax)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (typepred "x!1")
                                  (("2"
                                    (expand "Intab")
                                    (("2"
                                      (assert)
                                      (("2"
                                        (flatten)
                                        (("2"
                                          (assert)
                                          (("2"
                                            (expand "restrict")
                                            (("2" (propax) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("3" (lemma "closed_intervals_compact")
                        (("3" (inst - "a" "b")
                          (("3" (expand "Intab")
                            (("3" (propax) nil nil)) nil))
                          nil))
                        nil)
                       ("4" (hide-all-but -1)
                        (("4" (expand "empty?")
                          (("4" (inst - "a")
                            (("4" (expand "member")
                              (("4"
                                (expand "Intab")
                                (("4" (assertnil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (hide-all-but 1)
                  (("2" (expand "Intab")
                    (("2" (skosimp*) (("2" (ground) nil nil)) nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("3" (hide-all-but 1) (("3" (grind) nil nil)) nil)
           ("4" (hide-all-but 1) (("4" (grind) nil nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((Continuous_Function type-eq-decl nil riesz_interval_funs nil)
    (continuous_on_int? const-decl "bool" riesz_interval_funs nil)
    (INTab type-eq-decl nil riesz_interval_funs nil)
    (b formal-const-decl "{bb: real | a < bb}" riesz_representation
     nil)
    (< const-decl "bool" reals nil)
    (a formal-const-decl "real" riesz_representation nil)
    (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (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)
    (Intab const-decl "set[real]" riesz_interval_funs nil)
    (uniformly_continuous? const-decl "bool" uniform_continuity nil)
    (real_dist const-decl "nnreal" real_metric_space nil)
    (restrict const-decl "R" restrict nil)
    (nnreal type-eq-decl nil real_types nil)
    (>= const-decl "bool" reals nil) (set type-eq-decl nil sets nil)
    (fullset const-decl "set" sets nil)
    (metric_space? const-decl "bool" metric_spaces_def nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (total_order_restrict application-judgement "(total_order?[S])"
     restrict_order_props nil)
    (dichotomous_restrict application-judgement "(dichotomous?[S])"
     restrict_order_props nil)
    (partial_order_restrict application-judgement "(partial_order?[S])"
     restrict_order_props nil)
    (preorder_restrict application-judgement "(preorder?[S])"
     restrict_order_props nil)
    (transitive_restrict application-judgement "(transitive?[S])"
     restrict_order_props nil)
    (antisymmetric_restrict application-judgement "(antisymmetric?[S])"
     restrict_order_props nil)
    (reflexive_restrict application-judgement "(reflexive?[S])"
     restrict_order_props nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (barray type-eq-decl nil fseqs "structures/")
    (fseq type-eq-decl nil fseqs "structures/")
    (= const-decl "[T, T -> boolean]" equalities nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (increasing? const-decl "bool" sort_fseq "structures/")
    (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)
    (below type-eq-decl nil naturalnumbers nil)
    (partition type-eq-decl nil rs_partition nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (strictly_increasing? const-decl "bool" sort_fseq "structures/")
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (char_fun const-decl "nnreal" riesz_representation nil)
    (sigma_split formula-decl nil sigma "reals/")
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (sigma def-decl "real" sigma "reals/")
    (int_plus_int_is_int application-judgement "int" integers nil)
    (subrange type-eq-decl nil integers nil)
    (sigma_restrict_eq_0 formula-decl nil sigma "reals/")
    (real_plus_real_is_real application-judgement "real" reals nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (T_high type-eq-decl nil sigma "reals/")
    (T_low type-eq-decl nil sigma "reals/")
    (real_times_real_is_real application-judgement "real" reals nil)
    (x!1 skolem-const-decl "INTab[a, b]" riesz_representation nil)
    (P skolem-const-decl "partition[INTab](a, b)" riesz_representation
     nil)
    (xis skolem-const-decl "xis?[INTab](a, b, P)" riesz_representation
     nil)
    (ii!1 skolem-const-decl "below(P`length - 1)" riesz_representation
     nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (width_lem formula-decl nil rs_partition nil)
    (step_approx const-decl "(bounded_on_int?[a, b])"
     riesz_representation nil)
    (bounded_on_int? const-decl "bool" riesz_interval_funs nil)
    (xis? type-eq-decl nil rs_integral_def nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (ii!1 skolem-const-decl "below(PP`length - 1)" riesz_representation
     nil)
    (PP skolem-const-decl "partition[INTab](a, b)" riesz_representation
     nil)
    (part_in formula-decl nil rs_partition nil)
    (Heine formula-decl nil uniform_continuity nil)
    (x!1 skolem-const-decl
     "(restrict[real, INTab[a, b], boolean](Intab))"
     riesz_representation nil)
    (p!1 skolem-const-decl
     "(restrict[real, INTab[a, b], boolean](Intab))"
     riesz_representation nil)
    (ff skolem-const-decl "[real -> real]" riesz_representation nil)
    (continuous_at? const-decl "bool" continuity_ms_def nil)
    (y!1 skolem-const-decl "(Intab)" riesz_representation nil)
    (ball const-decl "set[T]" metric_spaces nil)
    (member const-decl "bool" sets nil)
    (x!1 skolem-const-decl "(Intab)" riesz_representation nil)
    (continuous? const-decl "bool" continuity_ms_def nil)
    (closed_intervals_compact formula-decl nil real_metric_space nil)
    (empty? const-decl "bool" sets nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (space_zero? const-decl "bool" metric_spaces_def nil)
    (space_symmetric? const-decl "bool" metric_spaces_def nil)
    (space_triangle? const-decl "bool" metric_spaces_def nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (minus_real_is_real application-judgement "real" reals nil)
    (real_minus_real_is_real application-judgement "real" reals nil))
   shostak))
 (IMP_riesz_bounded_functionals_TCC1 0
  (IMP_riesz_bounded_functionals_TCC1-1 nil 3493977883
   ("" (expand "fullset")
    (("" (expand "extend")
      (("" (expand "bounded_linear_subspace?")
        (("" (ground)
          (("1" (expand "funs_sum_closed?")
            (("1" (skolem 1 ("ff" "gg"))
              (("1" (ground)
                (("1" (typepred "ff")
                  (("1" (typepred "gg")
                    (("1" (lemma "sum_continuous")
                      (("1" (inst?)
                        (("1" (assert)
                          (("1" (expand "continuous_on_int?")
                            (("1" (inst?) (("1" (assertnil nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (expand "funs_const_closed?")
            (("2" (skolem 1 ("ff" "cc"))
              (("2" (ground)
                (("2" (typepred "ff")
                  (("2" (lemma "scal_continuous")
                    (("2" (inst?)
                      (("2" (assert)
                        (("2" (expand "continuous_on_int?")
                          (("2" (inst?) (("2" (assertnil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("3" (expand "funs_bounded?")
            (("3" (skolem 1 "ff")
              (("3" (typepred "ff")
                (("3" (lemma "continuous_implies_bounded[a,b]")
                  (("3" (inst - "ff"nil nil)) nil))
                nil))
              nil))
            nil)
           ("4" (expand "funs_contain_constants?")
            (("4" (skeep)
              (("4" (ground)
                (("4" (expand "continuous_on_int?")
                  (("4" (expand "continuous?")
                    (("4" (expand "continuous_at?")
                      (("4" (assert)
                        (("4" (expand "ball")
                          (("4" (expand "real_dist")
                            (("4" (assertnil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("5" (expand "funs_contain_continuous?")
            (("5" (skolem 1 "ff")
              (("5" (flatten) (("5" (ground) nil nil)) nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((extend const-decl "R" extend nil)
    (TRUE const-decl "bool" booleans nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (continuous_on_int? const-decl "bool" riesz_interval_funs nil)
    (INTab type-eq-decl nil riesz_interval_funs nil)
    (b formal-const-decl "{bb: real | a < bb}" riesz_representation
     nil)
    (< const-decl "bool" reals nil)
    (a formal-const-decl "real" riesz_representation nil)
    (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (FALSE const-decl "bool" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (sum_continuous formula-decl nil metric_space_real_fun nil)
    (>= const-decl "bool" reals nil)
    (nnreal type-eq-decl nil real_types nil)
    (restrict const-decl "R" restrict nil)
    (real_dist const-decl "nnreal" real_metric_space nil)
    (Intab const-decl "set[real]" riesz_interval_funs nil)
    (set type-eq-decl nil sets nil)
    (funs_sum_closed? const-decl "bool" riesz_function_sets nil)
    (scal_continuous formula-decl nil metric_space_real_fun nil)
    (funs_const_closed? const-decl "bool" riesz_function_sets nil)
    (continuous_implies_bounded formula-decl nil riesz_interval_funs
     nil)
    (Continuous_Function type-eq-decl nil riesz_interval_funs nil)
    (funs_bounded? const-decl "bool" riesz_function_sets nil)
    (continuous_at? const-decl "bool" continuity_ms_def nil)
    (ball const-decl "set[T]" metric_spaces nil)
    (abs_nat formula-decl nil abs_lems "reals/")
    (real_minus_real_is_real application-judgement "real" reals nil)
    (member const-decl "bool" sets nil)
    (continuous? const-decl "bool" continuity_ms_def nil)
    (funs_contain_constants? const-decl "bool" riesz_function_sets nil)
    (funs_contain_continuous? const-decl "bool" riesz_function_sets
     nil)
    (bounded_linear_subspace? const-decl "bool" riesz_function_sets
     nil)
    (fullset const-decl "set" sets nil))
   nil))
 (IMP_riesz_bounded_functionals_TCC2 0
  (IMP_riesz_bounded_functionals_TCC2-3 nil 3493978249
   ("" (expand "fullset")
    (("" (expand "extend")
      (("" (expand "bounded_linear_subspace?")
        (("" (ground)
          (("1" (expand "funs_sum_closed?")
            (("1" (skolem 1 ("ff" "gg"))
              (("1" (ground)
                (("1" (typepred "ff")
                  (("1" (typepred "gg")
                    (("1" (expand "bounded_on_int?")
                      (("1" (skosimp*)
                        (("1" (inst + "M!1+M!2")
                          (("1" (skosimp*)
                            (("1" (inst - "x!1")
                              (("1"
                                (inst - "x!1")
                                (("1"
                                  (grind :exclude "zero_off_int?")
                                  nil
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (expand "funs_const_closed?")
            (("2" (skolem 1 ("ff" "cc"))
              (("2" (ground)
                (("2" (typepred "ff")
                  (("2" (expand "bounded_on_int?")
                    (("2" (skosimp*)
                      (("2" (inst + "abs(cc)*M!1")
                        (("2" (skosimp*)
                          (("2" (inst - "x!1")
                            (("2" (expand "*")
                              (("2"
                                (rewrite "abs_mult")
                                (("2"
                                  (mult-by -1 "abs(cc)")
                                  (("2" (assertnil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("3" (expand "funs_bounded?") (("3" (propax) nil nil)) nil)
           ("4" (expand "funs_contain_constants?")
            (("4" (skeep)
              (("4" (ground)
                (("4" (expand "bounded_on_int?")
                  (("4" (inst + "abs(c)") (("4" (grind) nil nil)) nil))
                  nil))
                nil))
              nil))
            nil)
           ("5" (expand "funs_contain_continuous?")
            (("5" (skolem 1 "ff")
              (("5" (flatten)
                (("5" (ground)
                  (("5" (lemma "continuous_implies_bounded[a,b]")
                    (("5" (inst - "ff"nil nil)) nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((extend const-decl "R" extend nil)
    (TRUE const-decl "bool" booleans nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (bounded_on_int? const-decl "bool" riesz_interval_funs nil)
    (INTab type-eq-decl nil riesz_interval_funs nil)
    (b formal-const-decl "{bb: real | a < bb}" riesz_representation
     nil)
    (< const-decl "bool" reals nil)
    (a formal-const-decl "real" riesz_representation nil)
    (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (FALSE const-decl "bool" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (nnreal_plus_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (nnreal type-eq-decl nil real_types nil)
    (>= const-decl "bool" reals nil)
    (real_plus_real_is_real application-judgement "real" reals 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)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (+ const-decl "[T -> real]" real_fun_ops "reals/")
    (minus_real_is_real application-judgement "real" reals nil)
    (funs_sum_closed? const-decl "bool" riesz_function_sets nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (* const-decl "[T -> real]" real_fun_ops "reals/")
    (both_sides_times_pos_le1_imp formula-decl nil extra_real_props
     nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (abs_mult formula-decl nil real_props nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (nnreal_times_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (funs_const_closed? const-decl "bool" riesz_function_sets nil)
    (funs_bounded? const-decl "bool" riesz_function_sets nil)
    (funs_contain_constants? const-decl "bool" riesz_function_sets nil)
    (continuous_on_int? const-decl "bool" riesz_interval_funs nil)
    (Continuous_Function type-eq-decl nil riesz_interval_funs nil)
    (continuous_implies_bounded formula-decl nil riesz_interval_funs
     nil)
    (funs_contain_continuous? const-decl "bool" riesz_function_sets
     nil)
    (bounded_linear_subspace? const-decl "bool" riesz_function_sets
     nil)
    (fullset const-decl "set" sets nil))
   nil)
  (IMP_riesz_bounded_functionals_TCC2-2 nil 3493978219
   (";;; Proof IMP_riesz_bounded_functionals_TCC1-1 for formula riesz_representation.IMP_riesz_bounded_functionals_TCC1"
    (expand "fullset")
    ((";;; Proof IMP_riesz_bounded_functionals_TCC1-1 for formula riesz_representation.IMP_riesz_bounded_functionals_TCC1"
      (expand "extend")
      ((";;; Proof IMP_riesz_bounded_functionals_TCC1-1 for formula riesz_representation.IMP_riesz_bounded_functionals_TCC1"
        (expand "bounded_linear_subspace?")
        ((";;; Proof IMP_riesz_bounded_functionals_TCC1-1 for formula riesz_representation.IMP_riesz_bounded_functionals_TCC1"
          (ground)
          (("1" (expand "funs_sum_closed?")
            (("1" (skolem 1 ("ff" "gg"))
              (("1" (ground)
                (("1" (typepred "ff")
                  (("1" (typepred "gg")
                    (("1" (expand "zero_off_int_and_continuous?")
                      (("1" (ground)
                        (("1" (lemma "sum_continuous")
                          (("1" (inst?) (("1" (assertnil)))))
                         ("2" (expand "zero_off_int?")
                          (("2" (skosimp*)
                            (("2" (inst - "y!1")
                              (("2"
                                (inst - "y!1")
                                (("2"
                                  (assert)
                                  (("2"
                                    (expand "+")
                                    (("2"
                                      (assert)
                                      nil)))))))))))))))))))))))))))
           ("2" (expand "funs_const_closed?")
            (("2" (skolem 1 ("ff" "cc"))
              (("2" (ground)
                (("2" (typepred "ff")
                  (("2" (expand "zero_off_int_and_continuous?")
                    (("2" (ground)
                      (("1" (lemma "scal_continuous")
                        (("1" (inst?) (("1" (assertnil)))))
                       ("2" (expand "zero_off_int?")
                        (("2" (skosimp*)
                          (("2" (inst - "y!1")
                            (("2" (expand "*")
                              (("2" (assertnil)))))))))))))))))))))
           ("3" (expand "funs_bounded?")
            (("3" (skolem 1 "ff")
              (("3" (typepred "ff")
                (("3" (expand "zero_off_int_and_continuous?")
                  (("3" (flatten)
                    (("3" (lemma "continuous_implies_bounded[a,b]")
                      (("3" (inst - "ff")
                        (("3" (expand "zero_off_int_and_bounded?")
                          (("3" (ground) nil)))))))))))))))))
           ("4" (expand "funs_zero_off_int?")
            (("4" (skolem 1 "ff")
              (("4" (typepred "ff")
                (("4" (expand "zero_off_int_and_continuous?")
                  (("4" (expand "zero_off_int?")
                    (("4" (flatten) nil)))))))))))
           ("5" (expand "funs_contain_constants?")
            (("5" (skeep)
              (("5" (ground)
                (("5" (expand "zero_off_int_and_continuous?")
                  (("5" (split)
                    (("1" (expand "continuous?")
                      (("1" (skeep)
                        (("1" (expand "continuous_at?")
                          (("1" (skosimp*)
                            (("1" (inst + "1")
                              (("1" (grind) nil)))))))))))
                     ("2" (grind) nil)))))))))))
           ("6" (expand "funs_contain_continuous?")
            (("6" (skolem 1 "ff")
              (("6" (flatten) (("6" (ground) nil))))))))))))))
    ";;; developed with shostak decision procedures")
   nil nil)
  (IMP_riesz_bounded_functionals_TCC2-1 nil 3493977883
   ("" (assuming-tcc) nil nilnil nil))
 (riesz_representation_TCC1 0
  (riesz_representation_TCC1-1 nil 3492949849
   ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (a formal-const-decl "real" riesz_representation nil)
    (< const-decl "bool" reals nil)
    (b formal-const-decl "{bb: real | a < bb}" riesz_representation
     nil)
    (INTab type-eq-decl nil riesz_interval_funs nil)
    (continuous_on_int? const-decl "bool" riesz_interval_funs nil)
    (Operator type-eq-decl nil riesz_linear_functionals nil)
    (bounded_linear_operator? const-decl "bool"
     riesz_bounded_functionals nil)
    (C_Bounded_Linear_Operator type-eq-decl nil riesz_hahn_banach nil)
    (bounded_variation? const-decl "bool" bounded_variation nil)
    (variation_on const-decl "nnreal" bounded_variation nil)
    (linear_op? const-decl "bool" riesz_linear_functionals nil)
    (const_inv_op? const-decl "bool" riesz_linear_functionals nil)
    (additive_op? const-decl "bool" riesz_linear_functionals nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (partition type-eq-decl nil rs_partition nil)
    (below 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)
    (increasing? const-decl "bool" sort_fseq "structures/")
    (restrict const-decl "R" restrict nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (> const-decl "bool" reals nil)
    (fseq type-eq-decl nil fseqs "structures/")
    (barray type-eq-decl nil fseqs "structures/")
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (bounded_op? const-decl "bool" riesz_bounded_functionals nil)
    (real_minus_real_is_real application-judgement "real" reals nil))
   nil))
 (riesz_representation 0
  (riesz_representation-2 nil 3495206890
   ("" (auto-rewrite + "member")
    (("" (skeep)
      (("" (lemma "Hahn_Banach")
        (("" (inst - "LC")
          (("" (skeep -)
            ((""
              (name "gg"
                    "(LAMBDA (x:INTab): IF x = a THEN 0 ELSE LB(char_fun(a,x)) ENDIF)")
              (("1" (label "ggname" -1)
                (("1" (label "opeq" -2)
                  (("1" (label "LBLC" -3)
                    (("1"
                      (case "(FORALL (P:partition(a,b)): strictly_increasing?(P) IMPLIES variation_on(a,b,P)(gg) <= op_norm[a,b,Continuous_Function[a,b]](LC))")
                      (("1" (label "VPle" -1)
                        (("1"
                          (case "total_variation(a,b,gg)(b) <= op_norm[a,b,Continuous_Function[a,b]](LC)")
                          (("1" (label "TVle" -1)
                            (("1" (inst + "gg")
                              (("1"
                                (case "LC = fun_to_op(gg)")
                                (("1"
                                  (assert)
                                  (("1"
                                    (case
                                     "op_norm[a,b,Continuous_Function[a,b]](LC) <= total_variation(a,b,gg)(b)")
                                    (("1" (assertnil nil)
                                     ("2"
                                      (hide 2)
                                      (("2"
                                        (hide "TVle")
                                        (("2"
                                          (lemma "fun_to_op_bound")
                                          (("2"
                                            (typepred
                                             "op_norm[a,b,Continuous_Function[a,b]](LC)")
                                            (("2"
                                              (inst
                                               -3
                                               "total_variation(a,b,gg)(b)")
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (skosimp*)
                                                  (("2"
                                                    (inst - "f!1")
                                                    (("2"
                                                      (inst
                                                       -
                                                       "f!1"
                                                       "gg")
                                                      (("2"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (hide 2)
                                  (("2"
                                    (case
                                     "FORALL (epsil:posreal,ff:Continuous_Function[a,b]): EXISTS (delta:posreal): FORALL (P:partition(a,b),xis:xis?(a,b,P)): width(a,b,P)<delta and strictly_increasing?(P) IMPLIES abs(LB(step_approx(P,xis)(ff))-fun_to_op(gg)(ff)) < epsil")
                                    (("1"
                                      (case
                                       "FORALL (ff:Continuous_Function[a,b]): LC(ff) = fun_to_op(gg)(ff)")
                                      (("1"
                                        (decompose-equality +)
                                        nil
                                        nil)
                                       ("2"
                                        (hide 2)
                                        (("2"
                                          (skeep)
                                          (("2"
                                            (case
                                             "FORALL (epsil:posreal): abs(LC(ff)-fun_to_op(gg)(ff)) < 32*epsil")
                                            (("1"
                                              (case
                                               "abs(LC(ff)-fun_to_op(gg)(ff)) = 0")
                                              (("1"
                                                (lemma "abs_eq_0")
                                                (("1"
                                                  (inst?)
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (hide 2)
                                                (("2"
                                                  (inst
                                                   -
                                                   "abs(LC(ff)-fun_to_op(gg)(ff))/64")
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil)
                                                   ("2"
                                                    (cross-mult 1)
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (hide 2)
                                              (("2"
                                                (case
                                                 "FORALL (epsil:posreal,ff:Continuous_Function[a,b]): EXISTS (delta:posreal): FORALL (P:partition(a,b),xis:xis?(a,b,P)):
                                                                                                                                                                                                                                                                                                                                  strictly_increasing?(P) AND width(a,b,P)<delta IMPLIES abs(LC(ff)-LB(step_approx(P,xis)(ff)))<epsil")
                                                (("1"
                                                  (skeep)
                                                  (("1"
                                                    (inst
                                                     -
                                                     "epsil"
                                                     "ff")
                                                    (("1"
                                                      (inst
                                                       -
                                                       "epsil"
                                                       "ff")
                                                      (("1"
                                                        (skosimp*)
                                                        (("1"
                                                          (lemma
                                                           "partition_exists")
                                                          (("1"
                                                            (inst
                                                             -
                                                             "a"
                                                             "b"
                                                             "min(delta!1,delta!2)")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (skeep
                                                                 -)
                                                                (("1"
                                                                  (name
                                                                   "SSP"
                                                                   "strictly_sort(P)")
                                                                  (("1"
                                                                    (case
                                                                     "width(a,b,SSP) < min(delta!1,delta!2)")
                                                                    (("1"
                                                                      (hide
                                                                       -2)
                                                                      (("1"
                                                                        (hide
                                                                         -2)
                                                                        (("1"
                                                                          (name
                                                                           "xis"
                                                                           "gen_xis(a,b,SSP)")
                                                                          (("1"
                                                                            (inst
                                                                             -
                                                                             "SSP"
                                                                             "xis")
                                                                            (("1"
                                                                              (assert)
                                                                              (("1"
                                                                                (inst
                                                                                 -
                                                                                 "SSP"
                                                                                 "xis")
                                                                                (("1"
                                                                                  (assert)
                                                                                  (("1"
                                                                                    (hide-all-but
                                                                                     (-3
                                                                                      -4
                                                                                      +))
                                                                                    (("1"
                                                                                      (grind
                                                                                       :exclude
                                                                                       ("stop_approx"
                                                                                        "fun_to_op"))
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (lemma
                                                                       "partition_union_is_strictly_sort")
                                                                      (("2"
                                                                        (inst
                                                                         -
                                                                         "a"
                                                                         "b")
                                                                        (("2"
                                                                          (assert)
                                                                          (("2"
                                                                            (inst
                                                                             -
                                                                             "P")
                                                                            (("2"
                                                                              (lemma
                                                                               "partition_union_width")
                                                                              (("2"
                                                                                (inst
                                                                                 -
                                                                                 "a"
                                                                                 "b")
                                                                                (("2"
                                                                                  (assert)
                                                                                  (("2"
                                                                                    (inst
                                                                                     -
                                                                                     "P"
                                                                                     "P")
                                                                                    (("2"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("3"
                                                                      (lemma
                                                                       "partition_strictly_sort")
                                                                      (("3"
                                                                        (inst
                                                                         -
                                                                         "a"
                                                                         "b")
                                                                        (("3"
                                                                          (assert)
                                                                          (("3"
                                                                            (inst
                                                                             -
                                                                             "P")
                                                                            (("3"
                                                                              (flatten)
                                                                              (("3"
                                                                                (assert)
                                                                                (("3"
                                                                                  (skosimp*)
                                                                                  (("3"
                                                                                    (inst
                                                                                     -
                                                                                     "i!1")
                                                                                    (("3"
                                                                                      (ground)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (hide 2)
                                                  (("2"
                                                    (skosimp*)
                                                    (("2"
                                                      (typepred "LB")
                                                      (("2"
                                                        (expand
                                                         "bounded_linear_operator?")
                                                        (("2"
                                                          (flatten)
                                                          (("2"
                                                            (expand
                                                             "bounded_op?")
                                                            (("2"
                                                              (skosimp*)
                                                              (("2"
                                                                (lemma
                                                                 "step_approx_def")
                                                                (("2"
                                                                  (inst
                                                                   -
                                                                   "ff!1"
                                                                   "epsil!1/(M!1+1)")
                                                                  (("2"
                                                                    (skosimp*)
                                                                    (("2"
                                                                      (inst
                                                                       +
                                                                       "delta!1")
                                                                      (("2"
                                                                        (skeep)
                                                                        (("2"
                                                                          (inst
                                                                           -
                                                                           "P"
                                                                           "xis")
                                                                          (("2"
                                                                            (assert)
                                                                            (("2"
                                                                              (inst
                                                                               "LBLC"
                                                                               "ff!1")
                                                                              (("2"
                                                                                (replace
                                                                                 "LBLC"
                                                                                 :dir
                                                                                 rl)
                                                                                (("2"
                                                                                  (case
                                                                                   "LB(ff!1) - LB(step_approx(P, xis)(ff!1)) = LB(ff!1-step_approx(P,xis)(ff!1))")
                                                                                  (("1"
                                                                                    (replace
                                                                                     -1)
                                                                                    (("1"
                                                                                      (inst
                                                                                       -3
                                                                                       "ff!1 - step_approx(P, xis)(ff!1)")
                                                                                      (("1"
                                                                                        (case
                                                                                         "fun_norm(ff!1 - step_approx(P, xis)(ff!1)) <= epsil!1/(M!1+1)")
                                                                                        (("1"
                                                                                          (cross-mult
                                                                                           -1)
                                                                                          (("1"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (hide
                                                                                           2)
                                                                                          (("2"
                                                                                            (typepred
                                                                                             "fun_norm(ff!1 - step_approx(P, xis)(ff!1))")
                                                                                            (("2"
                                                                                              (inst
                                                                                               -3
                                                                                               "epsil!1/(M!1+1)")
                                                                                              (("2"
                                                                                                (assert)
                                                                                                (("2"
                                                                                                  (skosimp*)
                                                                                                  (("2"
                                                                                                    (inst
                                                                                                     -5
                                                                                                     "x!1")
                                                                                                    (("2"
                                                                                                      (expand
                                                                                                       "-")
                                                                                                      (("2"
                                                                                                        (assert)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil)
                                                                                   ("2"
                                                                                    (expand
                                                                                     "linear_op?")
                                                                                    (("2"
                                                                                      (flatten)
                                                                                      (("2"
                                                                                        (expand
                                                                                         "additive_op?")
                                                                                        (("2"
                                                                                          (inst
                                                                                           -
                                                                                           "ff!1"
                                                                                           "-1*step_approx(P,xis)(ff!1)")
                                                                                          (("1"
                                                                                            (expand
                                                                                             "const_inv_op?")
                                                                                            (("1"
                                                                                              (inst
                                                                                               -
                                                                                               "step_approx(P,xis)(ff!1)"
                                                                                               "-1")
                                                                                              (("1"
                                                                                                (case
                                                                                                 "ff!1+-1*step_approx(P,xis)(ff!1) = ff!1-step_approx(P,xis)(ff!1)")
                                                                                                (("1"
                                                                                                  (assert)
                                                                                                  nil
                                                                                                  nil)
                                                                                                 ("2"
                                                                                                  (hide-all-but
                                                                                                   1)
                                                                                                  (("2"
                                                                                                    (grind
                                                                                                     :exclude
                                                                                                     ("step_approx"))
                                                                                                    (("2"
                                                                                                      (decompose-equality
                                                                                                       +)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (hide-all-but
                                                                                             1)
                                                                                            (("2"
                                                                                              (typepred
                                                                                               "step_approx(P,xis)(ff!1)")
                                                                                              (("2"
                                                                                                (assert)
                                                                                                (("2"
                                                                                                  (expand
                                                                                                   "*")
                                                                                                  (("2"
                                                                                                    (assert)
                                                                                                    (("2"
                                                                                                      (expand
                                                                                                       "bounded_on_int?")
                                                                                                      (("2"
                                                                                                        (skosimp*)
                                                                                                        (("2"
                                                                                                          (inst
                                                                                                           +
                                                                                                           "M!2")
                                                                                                          (("2"
                                                                                                            (skosimp*)
                                                                                                            (("2"
                                                                                                              (inst
                                                                                                               -
                                                                                                               "x!1")
                                                                                                              (("2"
                                                                                                                (rewrite
                                                                                                                 "abs_mult")
                                                                                                                (("2"
                                                                                                                  (expand
                                                                                                                   "abs"
                                                                                                                   +
                                                                                                                   1)
                                                                                                                  (("2"
                                                                                                                    (assert)
                                                                                                                    nil
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil)
                                                                                   ("3"
                                                                                    (hide-all-but
                                                                                     1)
                                                                                    (("3"
                                                                                      (expand
                                                                                       "bounded_on_int?")
                                                                                      (("3"
                                                                                        (typepred
                                                                                         "step_approx(P,xis)(ff!1)")
                                                                                        (("3"
                                                                                          (typepred
                                                                                           "ff!1")
                                                                                          (("3"
                                                                                            (lemma
                                                                                             "continuous_implies_bounded")
                                                                                            (("3"
                                                                                              (inst
                                                                                               -
                                                                                               "ff!1")
                                                                                              (("3"
                                                                                                (hide
                                                                                                 -2)
                                                                                                (("3"
                                                                                                  (expand
                                                                                                   "bounded_on_int?")
                                                                                                  (("3"
                                                                                                    (skosimp*)
                                                                                                    (("3"
                                                                                                      (inst
                                                                                                       +
                                                                                                       "M!2+M!3")
                                                                                                      (("3"
                                                                                                        (skosimp*)
                                                                                                        (("3"
                                                                                                          (inst
                                                                                                           -
                                                                                                           "x!1")
                                                                                                          (("3"
                                                                                                            (inst
                                                                                                             -
                                                                                                             "x!1")
                                                                                                            (("3"
                                                                                                              (grind
                                                                                                               :exclude
                                                                                                               ("step_approx"))
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (case
                                       "FORALL (ff:Continuous_Function[a,b],P:partition(a,b),xis:xis?(a,b,P)): strictly_increasing?(P) IMPLIES LB(step_approx(P,xis)(ff)) = Rie_sum(a,b,gg,P,xis,ff)")
                                      (("1"
                                        (lemma "RS_integrable_cont_BV")
                                        (("1"
                                          (skeep)
                                          (("1"
                                            (inst - "a" "b" "ff" "gg")
                                            (("1"
                                              (assert)
                                              (("1"
                                                (split -)
                                                (("1"
                                                  (copy -1)
                                                  (("1"
                                                    (expand
                                                     "integrable?"
                                                     -1)
                                                    (("1"
                                                      (skosimp*)
                                                      (("1"
                                                        (lemma
                                                         "integral_def")
                                                        (("1"
                                                          (inst
                                                           -
                                                           "a"
                                                           "b"
                                                           "ff"
                                                           "gg"
                                                           "S!1")
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (case
                                                               "fun_to_op(gg)(ff) = S!1")
                                                              (("1"
                                                                (replace
                                                                 -1)
                                                                (("1"
                                                                  (expand
                                                                   "integral?")
                                                                  (("1"
                                                                    (inst
                                                                     -
                                                                     "epsil")
                                                                    (("1"
                                                                      (skosimp*)
                                                                      (("1"
                                                                        (inst
                                                                         +
                                                                         "delta!1")
                                                                        (("1"
                                                                          (skosimp*)
                                                                          (("1"
                                                                            (inst
                                                                             -
                                                                             "P!1")
                                                                            (("1"
                                                                              (assert)
                                                                              (("1"
                                                                                (inst
                                                                                 -
                                                                                 "Rie_sum(a,b,gg,P!1,xis!1,ff)")
                                                                                (("1"
                                                                                  (inst
                                                                                   -
                                                                                   "ff"
                                                                                   "P!1"
                                                                                   "xis!1")
                                                                                  (("1"
                                                                                    (assert)
                                                                                    (("1"
                                                                                      (replace
                                                                                       -5)
                                                                                      (("1"
                                                                                        (hide-all-but
                                                                                         (-3
                                                                                          1))
                                                                                        (("1"
                                                                                          (grind
                                                                                           :exclude
                                                                                           "Rie_sum")
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (lemma
                                                                                   "Riemann?_Rie")
                                                                                  (("2"
                                                                                    (inst
                                                                                     -
                                                                                     "a"
                                                                                     "b"
                                                                                     "ff"
                                                                                     "gg")
                                                                                    (("2"
                                                                                      (split
                                                                                       -)
                                                                                      (("1"
                                                                                        (inst
                                                                                         -
                                                                                         "P!1"
                                                                                         "xis!1")
                                                                                        nil
                                                                                        nil)
                                                                                       ("2"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (expand
                                                                 "fun_to_op"
                                                                 1)
                                                                (("2"
                                                                  (propax)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (typepred "ff")
                                                  (("2"
                                                    (hide-all-but
                                                     (-1 1))
                                                    (("2"
                                                      (expand
                                                       "continuous?")
                                                      (("2"
                                                        (expand
                                                         "continuous_on_int?")
                                                        (("2"
                                                          (expand
                                                           "continuous?")
                                                          (("2"
                                                            (skosimp*)
                                                            (("2"
                                                              (inst
                                                               -
                                                               "x!1")
                                                              (("1"
                                                                (expand
                                                                 "continuous_at?")
                                                                (("1"
                                                                  (skosimp*)
                                                                  (("1"
                                                                    (inst
                                                                     -
                                                                     "epsilon!1")
                                                                    (("1"
                                                                      (skosimp*)
                                                                      (("1"
                                                                        (inst
                                                                         +
                                                                         "delta!1")
                                                                        (("1"
                                                                          (skosimp*)
                                                                          (("1"
                                                                            (inst
                                                                             -
                                                                             "y!1")
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil)
                                                                             ("2"
                                                                              (expand
                                                                               "Intab")
                                                                              (("2"
                                                                                (expand
                                                                                 "restrict")
                                                                                (("2"
                                                                                  (propax)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (expand
                                                                 "Intab")
                                                                (("2"
                                                                  (expand
                                                                   "restrict")
                                                                  (("2"
                                                                    (propax)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("3"
                                                  (expand
                                                   "bounded_variation?")
                                                  (("3"
                                                    (inst
                                                     +
                                                     "op_norm[a,b,Continuous_Function[a,b]](LC)")
                                                    (("3"
                                                      (skeep)
                                                      (("3"
                                                        (inst
                                                         -
                                                         "strictly_sort(P)")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (lemma
                                                             "variation_on_strictly_sort")
                                                            (("1"
                                                              (inst
                                                               -
                                                               "a"
                                                               "b")
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (inst
                                                                   -
                                                                   "P")
                                                                  (("1"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (hide-all-but
                                                           1)
                                                          (("2"
                                                            (lemma
                                                             "partition_strictly_sort")
                                                            (("2"
                                                              (inst
                                                               -
                                                               "a"
                                                               "b")
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (inst
                                                                   -
                                                                   "P")
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (hide 2)
                                        (("2"
                                          (hide 2)
                                          (("2"
                                            (skeep)
                                            (("2"
                                              (case
                                               "LB(step_approx(P, xis)(ff)) = sigma[below(P`length - 1)]
                                                                                                                                                                                                        (0, P`length - 2,
                                                                                                                                                                                                         LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                                                           ff(xis`seq(n)) * LB(char_fun(P`seq(n), P`seq(1 + n))))")
                                              (("1"
                                                (replace -1)
                                                (("1"
                                                  (hide -1)
                                                  (("1"
                                                    (expand
                                                     "Rie_sum"
                                                     +)
                                                    (("1"
                                                      (rewrite
                                                       "sigma_restrict_eq")
                                                      (("1"
                                                        (hide 2)
                                                        (("1"
                                                          (decompose-equality
                                                           +)
                                                          (("1"
                                                            (expand
                                                             "restrict")
                                                            (("1"
                                                              (lemma
                                                               "char_fun_minus")
                                                              (("1"
                                                                (inst
                                                                 -
                                                                 "a"
                                                                 "P`seq(x!1)"
                                                                 "P`seq(1+x!1)")
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (case
                                                                     "a <= P`seq(x!1) AND P`seq(x!1) < P`seq(1 + x!1)")
                                                                    (("1"
                                                                      (flatten)
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (expand
                                                                           "gg"
                                                                           +)
                                                                          (("1"
                                                                            (case
                                                                             "Intab(P`seq(1+x!1)) AND Intab(P`seq(x!1))")
                                                                            (("1"
                                                                              (flatten)
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (lift-if)
                                                                                  (("1"
                                                                                    (assert)
                                                                                    (("1"
                                                                                      (ground)
                                                                                      (("1"
                                                                                        (hide
                                                                                         1)
                                                                                        (("1"
                                                                                          (typepred
                                                                                           "LB")
                                                                                          (("1"
                                                                                            (expand
                                                                                             "bounded_linear_operator?")
                                                                                            (("1"
                                                                                              (expand
                                                                                               "linear_op?")
                                                                                              (("1"
                                                                                                (case
                                                                                                 "LB(char_fun(a, P`seq(1 + x!1)) - char_fun(a, P`seq(x!1))) = LB(char_fun(a, P`seq(1 + x!1))) - LB(char_fun(a, P`seq(x!1)))")
                                                                                                (("1"
                                                                                                  (assert)
                                                                                                  nil
                                                                                                  nil)
                                                                                                 ("2"
                                                                                                  (hide
                                                                                                   2)
                                                                                                  (("2"
                                                                                                    (flatten)
                                                                                                    (("2"
                                                                                                      (expand
                                                                                                       "additive_op?")
                                                                                                      (("2"
                                                                                                        (inst
                                                                                                         -
                                                                                                         "char_fun(a, P`seq(1 + x!1))"
                                                                                                         "-1*char_fun(a, P`seq(x!1))")
                                                                                                        (("1"
                                                                                                          (expand
                                                                                                           "const_inv_op?")
                                                                                                          (("1"
                                                                                                            (inst
                                                                                                             -
                                                                                                             "char_fun(a,P`seq(x!1))"
                                                                                                             "-1")
                                                                                                            (("1"
                                                                                                              (case
                                                                                                               "char_fun(a, P`seq(1 + x!1)) + -1 * char_fun(a, P`seq(x!1)) = char_fun(a, P`seq(1 + x!1)) - char_fun(a, P`seq(x!1))")
                                                                                                              (("1"
                                                                                                                (assert)
                                                                                                                nil
                                                                                                                nil)
                                                                                                               ("2"
                                                                                                                (decompose-equality
                                                                                                                 +)
                                                                                                                (("2"
                                                                                                                  (expand
                                                                                                                   "-")
                                                                                                                  (("2"
                                                                                                                    (expand
                                                                                                                     "+")
                                                                                                                    (("2"
                                                                                                                      (expand
                                                                                                                       "*")
                                                                                                                      (("2"
                                                                                                                        (assert)
                                                                                                                        nil
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (expand
                                                                                                           "bounded_on_int?")
                                                                                                          (("2"
                                                                                                            (inst
                                                                                                             +
                                                                                                             "1")
                                                                                                            (("2"
                                                                                                              (hide-all-but
                                                                                                               1)
                                                                                                              (("2"
                                                                                                                (grind)
                                                                                                                nil
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil)
                                                                                                 ("3"
                                                                                                  (hide-all-but
                                                                                                   1)
                                                                                                  (("3"
                                                                                                    (expand
                                                                                                     "bounded_on_int?")
                                                                                                    (("3"
                                                                                                      (inst
                                                                                                       +
                                                                                                       "2")
                                                                                                      (("3"
                                                                                                        (grind)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (hide-all-but
                                                                               1)
                                                                              (("2"
                                                                                (expand
                                                                                 "Intab")
                                                                                (("2"
                                                                                  (propax)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (expand
                                                                       "strictly_increasing?")
                                                                      (("2"
                                                                        (inst
                                                                         -
                                                                         "x!1"
                                                                         "1+x!1")
                                                                        (("2"
                                                                          (assert)
                                                                          (("2"
                                                                            (ground)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (hide-all-but
                                                             1)
                                                            (("2"
                                                              (skeep)
                                                              (("2"
                                                                (expand
                                                                 "bounded_on_int?")
                                                                (("2"
                                                                  (inst
                                                                   +
                                                                   "1")
                                                                  (("2"
                                                                    (grind)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (hide 2)
                                                (("2"
                                                  (expand
                                                   "step_approx"
                                                   +)
                                                  (("2"
                                                    (case
                                                     "FORALL (nn:below(P`length-1)): LB(LAMBDA (x:INTab):
                                                                                                                                                                        sigma[below(P`length - 1)]
                                                                                                                                                                            (0, nn,
                                                                                                                                                                             LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                               ff(xis`seq(n)) * char_fun(P`seq(n), P`seq(1 + n))(x)))
                                                                                                                                                                    =
                                                                                                                                                                    sigma[below(P`length - 1)]
                                                                                                                                                                        (0, nn,
                                                                                                                                                                         LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                           ff(xis`seq(n)) * LB(char_fun(P`seq(n), P`seq(1 + n))))")
                                                    (("1"
                                                      (inst
                                                       -
                                                       "P`length-2")
                                                      nil
                                                      nil)
                                                     ("2"
                                                      (hide 2)
                                                      (("2"
                                                        (induct "nn")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (expand
                                                             "sigma")
                                                            (("1"
                                                              (expand
                                                               "sigma")
                                                              (("1"
                                                                (typepred
                                                                 "LB")
                                                                (("1"
                                                                  (expand
                                                                   "bounded_linear_operator?")
                                                                  (("1"
                                                                    (expand
                                                                     "linear_op?")
                                                                    (("1"
                                                                      (expand
                                                                       "const_inv_op?")
                                                                      (("1"
                                                                        (flatten)
                                                                        (("1"
                                                                          (inst
                                                                           -
                                                                           "char_fun(P`seq(0),P`seq(1))"
                                                                           "ff(xis`seq(0))")
                                                                          (("1"
                                                                            (expand
                                                                             "*")
                                                                            (("1"
                                                                              (propax)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (skolem
                                                           1
                                                           "nn")
                                                          (("2"
                                                            (flatten)
                                                            (("2"
                                                              (expand
                                                               "sigma"
                                                               +)
                                                              (("2"
                                                                (replace
                                                                 -2
                                                                 :dir
                                                                 rl)
                                                                (("2"
                                                                  (typepred
                                                                   "LB")
                                                                  (("2"
                                                                    (expand
                                                                     "bounded_linear_operator?")
                                                                    (("2"
                                                                      (expand
                                                                       "linear_op?")
                                                                      (("2"
                                                                        (expand
                                                                         "additive_op?")
                                                                        (("2"
                                                                          (flatten)
                                                                          (("2"
                                                                            (inst
                                                                             -
                                                                             "LAMBDA (x:INTab):
                                                                                                                                                                 sigma(0, nn,
                                                                                                                                                                       LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                         ff(xis`seq(n)) * char_fun(P`seq(n), P`seq(1 + n))(x))"
                                                                             "LAMBDA (x:INTab):
                                                                                                                                                                 ff(xis`seq(1 + nn)) *
                                                                                                                                                                   char_fun(P`seq(1 + nn), P`seq(2 + nn))(x)")
                                                                            (("1"
                                                                              (expand
                                                                               "+")
                                                                              (("1"
                                                                                (replace
                                                                                 -2)
                                                                                (("1"
                                                                                  (expand
                                                                                   "const_inv_op?")
                                                                                  (("1"
                                                                                    (inst
                                                                                     -
                                                                                     "char_fun(P`seq(1 + nn), P`seq(2 + nn))"
                                                                                     "ff(xis`seq(1 + nn))")
                                                                                    (("1"
                                                                                      (expand
                                                                                       "*")
                                                                                      (("1"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (hide-all-but
                                                                               1)
                                                                              (("2"
                                                                                (expand
                                                                                 "bounded_on_int?")
                                                                                (("2"
                                                                                  (inst
                                                                                   +
                                                                                   "abs(ff(xis`seq(1+nn)))")
                                                                                  (("2"
                                                                                    (grind)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("3"
                                                                              (hide-all-but
                                                                               1)
                                                                              (("3"
                                                                                (expand
                                                                                 "bounded_on_int?")
                                                                                (("3"
                                                                                  (inst
                                                                                   +
                                                                                   "fun_norm(ff)*(nn+1)")
                                                                                  (("3"
                                                                                    (skeep)
                                                                                    (("3"
                                                                                      (case
                                                                                       "FORALL (mm:below(nn+1)): abs(sigma[below(P`length - 1)]
                                                                                                                                                                                                                                           (0, mm,
                                                                                                                                                                                                                                            LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                                                                                              ff(xis`seq(n)) * char_fun(P`seq(n), P`seq(1 + n))(x_1)))
                                                                                                                                                                                                                                    <= fun_norm(ff) * (mm + 1)")
                                                                                      (("1"
                                                                                        (inst
                                                                                         -
                                                                                         "nn")
                                                                                        nil
                                                                                        nil)
                                                                                       ("2"
                                                                                        (hide
                                                                                         2)
                                                                                        (("2"
                                                                                          (induct
                                                                                           "mm")
                                                                                          (("1"
                                                                                            (assert)
                                                                                            (("1"
                                                                                              (expand
                                                                                               "sigma")
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "sigma")
                                                                                                (("1"
                                                                                                  (typepred
                                                                                                   "fun_norm(ff)")
                                                                                                  (("1"
                                                                                                    (inst
                                                                                                     -
                                                                                                     "xis`seq(0)")
                                                                                                    (("1"
                                                                                                      (hide
                                                                                                       -3)
                                                                                                      (("1"
                                                                                                        (grind)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (skolem
                                                                                             1
                                                                                             "mm")
                                                                                            (("2"
                                                                                              (assert)
                                                                                              (("2"
                                                                                                (flatten)
                                                                                                (("2"
                                                                                                  (expand
                                                                                                   "sigma"
                                                                                                   +)
                                                                                                  (("2"
                                                                                                    (lemma
                                                                                                     "triangle")
                                                                                                    (("2"
                                                                                                      (inst?)
                                                                                                      (("2"
                                                                                                        (case
                                                                                                         "abs(ff(xis`seq(1 + mm)) *
                                                                                                                                                                                                                                                       char_fun(P`seq(1 + mm), P`seq(2 + mm))(x_1)) <= fun_norm(ff)")
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          nil
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (hide
                                                                                                           2)
                                                                                                          (("2"
                                                                                                            (hide
                                                                                                             -1)
                                                                                                            (("2"
                                                                                                              (hide
                                                                                                               -2)
                                                                                                              (("2"
                                                                                                                (typepred
                                                                                                                 "fun_norm(ff)")
                                                                                                                (("2"
                                                                                                                  (inst
                                                                                                                   -
                                                                                                                   "xis`seq(1+mm)")
                                                                                                                  (("2"
                                                                                                                    (hide
                                                                                                                     -3)
                                                                                                                    (("2"
                                                                                                                      (grind)
                                                                                                                      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)
                                                         ("3"
                                                          (hide-all-but
                                                           1)
                                                          (("3"
                                                            (skosimp*)
                                                            (("3"
                                                              (expand
                                                               "bounded_on_int?")
                                                              (("3"
                                                                (inst
                                                                 +
                                                                 "1")
                                                                (("3"
                                                                  (grind)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("4"
                                                          (hide-all-but
                                                           1)
                                                          (("4"
                                                            (skeep)
                                                            (("4"
                                                              (expand
                                                               "bounded_on_int?")
                                                              (("4"
                                                                (inst
                                                                 +
                                                                 "fun_norm(ff)*(nn+1)")
                                                                (("4"
                                                                  (skeep)
                                                                  (("4"
                                                                    (case
                                                                     "FORALL (mm:below(nn+1)): abs(sigma[below(P`length - 1)]
                                                                                                                                                                                                                                       (0, mm,
                                                                                                                                                                                                                                        LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                                                                                          ff(xis`seq(n)) * char_fun(P`seq(n), P`seq(1 + n))(x_1)))
                                                                                                                                                                                                                                <= fun_norm(ff) * (mm + 1)")
                                                                    (("1"
                                                                      (inst
                                                                       -
                                                                       "nn")
                                                                      nil
                                                                      nil)
                                                                     ("2"
                                                                      (hide
                                                                       2)
                                                                      (("2"
                                                                        (induct
                                                                         "mm")
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (expand
                                                                             "sigma")
                                                                            (("1"
                                                                              (expand
                                                                               "sigma")
                                                                              (("1"
                                                                                (typepred
                                                                                 "fun_norm(ff)")
                                                                                (("1"
                                                                                  (inst
                                                                                   -
                                                                                   "xis`seq(0)")
                                                                                  (("1"
                                                                                    (hide
                                                                                     -3)
                                                                                    (("1"
                                                                                      (grind)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (skolem
                                                                           1
                                                                           "mm")
                                                                          (("2"
                                                                            (assert)
                                                                            (("2"
                                                                              (flatten)
                                                                              (("2"
                                                                                (expand
                                                                                 "sigma"
                                                                                 +)
                                                                                (("2"
                                                                                  (lemma
                                                                                   "triangle")
                                                                                  (("2"
                                                                                    (inst?)
                                                                                    (("2"
                                                                                      (case
                                                                                       "abs(ff(xis`seq(1 + mm)) *
                                                                                                                                                                                                                                                   char_fun(P`seq(1 + mm), P`seq(2 + mm))(x_1)) <= fun_norm(ff)")
                                                                                      (("1"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil)
                                                                                       ("2"
                                                                                        (hide
                                                                                         2)
                                                                                        (("2"
                                                                                          (hide
                                                                                           -1)
                                                                                          (("2"
                                                                                            (hide
                                                                                             -2)
                                                                                            (("2"
                                                                                              (typepred
                                                                                               "fun_norm(ff)")
                                                                                              (("2"
                                                                                                (inst
                                                                                                 -
                                                                                                 "xis`seq(1+mm)")
                                                                                                (("2"
                                                                                                  (hide
                                                                                                   -3)
                                                                                                  (("2"
                                                                                                    (grind)
                                                                                                    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)
                                                     ("3"
                                                      (hide-all-but 1)
                                                      (("3"
                                                        (skosimp*)
                                                        (("3"
                                                          (expand
                                                           "bounded_on_int?")
                                                          (("3"
                                                            (inst
                                                             +
                                                             "1")
                                                            (("3"
                                                              (grind)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("4"
                                                      (skeep)
                                                      (("4"
                                                        (hide-all-but
                                                         1)
                                                        (("4"
                                                          (expand
                                                           "bounded_on_int?")
                                                          (("4"
                                                            (inst
                                                             +
                                                             "fun_norm(ff)*(nn+1)")
                                                            (("4"
                                                              (skeep)
                                                              (("4"
                                                                (case
                                                                 "FORALL (mm:below(nn+1)): abs(sigma[below(P`length - 1)]
                                                                                                                                                                                                                                   (0, mm,
                                                                                                                                                                                                                                    LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                                                                                      ff(xis`seq(n)) * char_fun(P`seq(n), P`seq(1 + n))(x_1)))
                                                                                                                                                                                                                            <= fun_norm(ff) * (mm + 1)")
                                                                (("1"
                                                                  (inst
                                                                   -
                                                                   "nn")
                                                                  nil
                                                                  nil)
                                                                 ("2"
                                                                  (hide
                                                                   2)
                                                                  (("2"
                                                                    (induct
                                                                     "mm")
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (expand
                                                                         "sigma")
                                                                        (("1"
                                                                          (expand
                                                                           "sigma")
                                                                          (("1"
                                                                            (typepred
                                                                             "fun_norm(ff)")
                                                                            (("1"
                                                                              (inst
                                                                               -
                                                                               "xis`seq(0)")
                                                                              (("1"
                                                                                (hide
                                                                                 -3)
                                                                                (("1"
                                                                                  (grind)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (skolem
                                                                       1
                                                                       "mm")
                                                                      (("2"
                                                                        (assert)
                                                                        (("2"
                                                                          (flatten)
                                                                          (("2"
                                                                            (expand
                                                                             "sigma"
                                                                             +)
                                                                            (("2"
                                                                              (lemma
                                                                               "triangle")
                                                                              (("2"
                                                                                (inst?)
                                                                                (("2"
                                                                                  (case
                                                                                   "abs(ff(xis`seq(1 + mm)) *
                                                                                                                                                                                                                                               char_fun(P`seq(1 + mm), P`seq(2 + mm))(x_1)) <= fun_norm(ff)")
                                                                                  (("1"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil)
                                                                                   ("2"
                                                                                    (hide
                                                                                     2)
                                                                                    (("2"
                                                                                      (hide
                                                                                       -1)
                                                                                      (("2"
                                                                                        (hide
                                                                                         -2)
                                                                                        (("2"
                                                                                          (typepred
                                                                                           "fun_norm(ff)")
                                                                                          (("2"
                                                                                            (inst
                                                                                             -
                                                                                             "xis`seq(1+mm)")
                                                                                            (("2"
                                                                                              (hide
                                                                                               -3)
                                                                                              (("2"
                                                                                                (grind)
                                                                                                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)
                                               ("3"
                                                (hide-all-but 1)
                                                (("3"
                                                  (skeep)
                                                  (("3"
                                                    (expand
                                                     "bounded_on_int?")
                                                    (("3"
                                                      (inst + "1")
                                                      (("3"
                                                        (grind)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (hide 2)
                            (("2"
                              (typepred "total_variation(a,b,gg)(b)")
                              (("2"
                                (hide -2)
                                (("2"
                                  (assert)
                                  (("2"
                                    (inst
                                     -3
                                     "op_norm[a,b,Continuous_Function[a,b]](LC)")
                                    (("2"
                                      (assert)
                                      (("2"
                                        (skosimp*)
                                        (("2"
                                          (inst - "strictly_sort(P!1)")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (inst
                                               -
                                               "strictly_sort(P!1)")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (lemma
                                                   "variation_on_strictly_sort")
                                                  (("1"
                                                    (inst - "a" "b")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (inst - "P!1")
                                                        (("1"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (hide-all-but 1)
                                            (("2"
                                              (typepred "b")
                                              (("2"
                                                (lemma
                                                 "partition_strictly_sort")
                                                (("2"
                                                  (inst - "a" "b")
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (inst - "P!1")
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("3" (hide 2)
                            (("3" (expand "bounded_variation?")
                              (("3"
                                (inst
                                 +
                                 "op_norm[a,b,Continuous_Function[a,b]](LC)")
                                (("3"
                                  (skeep)
                                  (("3"
                                    (inst - "strictly_sort(P)")
                                    (("1"
                                      (assert)
                                      (("1"
                                        (lemma
                                         "variation_on_strictly_sort")
                                        (("1"
                                          (inst - "a" "b")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (inst - "P")
                                              (("1"
                                                (lemma
                                                 "variation_on_strictly_sort")
                                                (("1"
                                                  (inst - "a" "b")
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (hide-all-but 1)
                                      (("2"
                                        (typepred "b")
                                        (("2"
                                          (lemma
                                           "partition_strictly_sort")
                                          (("2"
                                            (inst - "a" "b")
                                            (("1"
                                              (assert)
                                              (("1"
                                                (inst - "P")
                                                nil
                                                nil))
                                              nil)
                                             ("2" (assertnil nil)
                                             ("3" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("4" (typepred "b") (("4" (assertnil nil))
                            nil)
                           ("5" (assertnil nil)
                           ("6" (assertnil nil))
                          nil))
                        nil)
                       ("2" (hide 2)
                        (("2" (skeep)
                          (("2"
                            (name "siggy"
                                  "(# length := P`length-1, seq:= (LAMBDA (nn:nat): IF nn >= P`length THEN default[INTab] ELSE sign(gg(P`seq(nn+1))-gg(P`seq(nn))) ENDIF) #)")
                            (("2"
                              (case "FORALL (mm: below(P`length - 1)):
                                                    bounded_on_int?[a, b]
                                                        (LAMBDA (x:INTab):
                                                           sigma[below(P`length - 1)]
                                                               (0, mm,
                                                                LAMBDA (nn: below(P`length - 1)):
                                                                  siggy`seq(nn) *
                                                                   char_fun(P`seq(nn), P`seq(1 + nn))(x)))")
                              (("1"
                                (label "blem" -1)
                                (("1"
                                  (hide "blem")
                                  (("1"
                                    (case
                                     "FORALL (mm:below(P`length-1)): LB(LAMBDA (x:INTab):
                                                                                                                   sigma[below(P`length - 1)]
                                                                                                                       (0, mm,
                                                                                                                        LAMBDA (nn: below(P`length - 1)):
                                                                                                                          siggy`seq(nn) * char_fun(P`seq(nn), P`seq(1 + nn))(x))) =
                                                                                                                   sigma[below(P`length - 1)]
                                                                                                                       (0, mm,
                                                                                                                        LAMBDA (nn: below(P`length - 1)):
                                                                                                                          siggy`seq(nn) * LB(char_fun(P`seq(nn), P`seq(1 + nn))))")
                                    (("1"
                                      (label "alem" -1)
                                      (("1"
                                        (hide "alem")
                                        (("1"
                                          (name
                                           "sigfun"
                                           "LAMBDA (x:INTab): sigma[below(P`length-1)](0,P`length-2,LAMBDA (nn:below(P`length-1)): siggy`seq(nn)*char_fun(P`seq(nn),P`seq(1+nn))(x))")
                                          (("1"
                                            (case
                                             "variation_on(a,b,P)(gg) = LB(sigfun) AND fun_norm(sigfun) <= 1")
                                            (("1"
                                              (flatten)
                                              (("1"
                                                (name
                                                 "NN"
                                                 "op_norm[a, b, Bounded_Function[a,b]](LB)")
                                                (("1"
                                                  (typepred "NN")
                                                  (("1"
                                                    (inst - "sigfun")
                                                    (("1"
                                                      (expand "abs" -2)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (mult-by
                                                           -6
                                                           "NN")
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (hide 2)
                                              (("2"
                                                (split +)
                                                (("1"
                                                  (expand "sigfun" +)
                                                  (("1"
                                                    (reveal "alem")
                                                    (("1"
                                                      (copy "alem")
                                                      (("1"
                                                        (hide "alem")
                                                        (("1"
                                                          (inst
                                                           -
                                                           "P`length-2")
                                                          (("1"
                                                            (replace
                                                             -1)
                                                            (("1"
                                                              (hide -1)
                                                              (("1"
                                                                (expand
                                                                 "variation_on"
                                                                 +)
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (rewrite
                                                                     "sigma_restrict_eq")
                                                                    (("1"
                                                                      (hide
                                                                       2)
                                                                      (("1"
                                                                        (decompose-equality
                                                                         +)
                                                                        (("1"
                                                                          (expand
                                                                           "restrict")
                                                                          (("1"
                                                                            (case
                                                                             "gg(P`seq(1 + x!1)) - gg(P`seq(x!1)) = LB(char_fun(P`seq(x!1), P`seq(1 + x!1)))")
                                                                            (("1"
                                                                              (hide-all-but
                                                                               (-1
                                                                                1))
                                                                              (("1"
                                                                                (replace
                                                                                 -1)
                                                                                (("1"
                                                                                  (expand
                                                                                   "siggy")
                                                                                  (("1"
                                                                                    (replace
                                                                                     -1)
                                                                                    (("1"
                                                                                      (hide
                                                                                       -1)
                                                                                      (("1"
                                                                                        (grind
                                                                                         :exclude
                                                                                         "char_fun")
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (hide
                                                                               2)
                                                                              (("2"
                                                                                (expand
                                                                                 "gg"
                                                                                 +)
                                                                                (("2"
                                                                                  (case
                                                                                   "Intab(P`seq(1 + x!1)) AND Intab(P`seq(x!1))")
                                                                                  (("1"
                                                                                    (flatten)
                                                                                    (("1"
                                                                                      (assert)
                                                                                      (("1"
                                                                                        (lift-if)
                                                                                        (("1"
                                                                                          (lift-if)
                                                                                          (("1"
                                                                                            (lift-if)
                                                                                            (("1"
                                                                                              (assert)
                                                                                              (("1"
                                                                                                (ground)
                                                                                                (("1"
                                                                                                  (name
                                                                                                   "zerofun"
                                                                                                   "(LAMBDA (x:INTab): 0)")
                                                                                                  (("1"
                                                                                                    (case
                                                                                                     "char_fun(P`seq(x!1),P`seq(1+x!1)) = zerofun")
                                                                                                    (("1"
                                                                                                      (replace
                                                                                                       -1)
                                                                                                      (("1"
                                                                                                        (typepred
                                                                                                         "LB")
                                                                                                        (("1"
                                                                                                          (expand
                                                                                                           "bounded_linear_operator?")
                                                                                                          (("1"
                                                                                                            (expand
                                                                                                             "linear_op?")
                                                                                                            (("1"
                                                                                                              (expand
                                                                                                               "additive_op?")
                                                                                                              (("1"
                                                                                                                (flatten)
                                                                                                                (("1"
                                                                                                                  (inst
                                                                                                                   -
                                                                                                                   "zerofun"
                                                                                                                   "zerofun")
                                                                                                                  (("1"
                                                                                                                    (case
                                                                                                                     "zerofun+zerofun = zerofun")
                                                                                                                    (("1"
                                                                                                                      (assert)
                                                                                                                      nil
                                                                                                                      nil)
                                                                                                                     ("2"
                                                                                                                      (hide-all-but
                                                                                                                       1)
                                                                                                                      (("2"
                                                                                                                        (decompose-equality
                                                                                                                         +)
                                                                                                                        (("2"
                                                                                                                          (expand
                                                                                                                           "zerofun")
                                                                                                                          (("2"
                                                                                                                            (propax)
                                                                                                                            nil
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (replace
                                                                                                       -1
                                                                                                       :dir
                                                                                                       rl)
                                                                                                      (("2"
                                                                                                        (replace
                                                                                                         -2)
                                                                                                        (("2"
                                                                                                          (replace
                                                                                                           -3)
                                                                                                          (("2"
                                                                                                            (hide-all-but
                                                                                                             1)
                                                                                                            (("2"
                                                                                                              (grind)
                                                                                                              (("2"
                                                                                                                (expand
                                                                                                                 "char_fun")
                                                                                                                (("2"
                                                                                                                  (grind)
                                                                                                                  (("2"
                                                                                                                    (decompose-equality
                                                                                                                     +)
                                                                                                                    nil
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil)
                                                                                                 ("2"
                                                                                                  (typepred
                                                                                                   "P")
                                                                                                  (("2"
                                                                                                    (expand
                                                                                                     "increasing?")
                                                                                                    (("2"
                                                                                                      (inst
                                                                                                       -
                                                                                                       "x!1"
                                                                                                       "1+x!1")
                                                                                                      (("2"
                                                                                                        (assert)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil)
                                                                                                 ("3"
                                                                                                  (case
                                                                                                   "P`seq(x!1) < P`seq(1+x!1)")
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    (("1"
                                                                                                      (lemma
                                                                                                       "char_fun_minus")
                                                                                                      (("1"
                                                                                                        (expand
                                                                                                         "Intab")
                                                                                                        (("1"
                                                                                                          (flatten)
                                                                                                          (("1"
                                                                                                            (inst
                                                                                                             -
                                                                                                             "a"
                                                                                                             "P`seq(x!1)"
                                                                                                             "P`seq(1+x!1)")
                                                                                                            (("1"
                                                                                                              (assert)
                                                                                                              (("1"
                                                                                                                (replace
                                                                                                                 -1
                                                                                                                 :dir
                                                                                                                 rl)
                                                                                                                (("1"
                                                                                                                  (hide-all-but
                                                                                                                   2)
                                                                                                                  (("1"
                                                                                                                    (typepred
                                                                                                                     "LB")
                                                                                                                    (("1"
                                                                                                                      (expand
                                                                                                                       "bounded_linear_operator?")
                                                                                                                      (("1"
                                                                                                                        (expand
                                                                                                                         "linear_op?")
                                                                                                                        (("1"
                                                                                                                          (expand
                                                                                                                           "additive_op?")
                                                                                                                          (("1"
                                                                                                                            (expand
                                                                                                                             "const_inv_op?")
                                                                                                                            (("1"
                                                                                                                              (flatten)
                                                                                                                              (("1"
                                                                                                                                (inst
                                                                                                                                 -
                                                                                                                                 "char_fun(a, P`seq(1 + x!1))"
                                                                                                                                 "-1*char_fun(a, P`seq(x!1))")
                                                                                                                                (("1"
                                                                                                                                  (inst
                                                                                                                                   -
                                                                                                                                   "char_fun(a, P`seq(x!1))"
                                                                                                                                   "-1")
                                                                                                                                  (("1"
                                                                                                                                    (case
                                                                                                                                     "char_fun(a, P`seq(1 + x!1)) + -1 * char_fun(a, P`seq(x!1)) = char_fun(a, P`seq(1 + x!1)) - char_fun(a, P`seq(x!1))")
                                                                                                                                    (("1"
                                                                                                                                      (assert)
                                                                                                                                      nil
                                                                                                                                      nil)
                                                                                                                                     ("2"
                                                                                                                                      (hide-all-but
                                                                                                                                       1)
                                                                                                                                      (("2"
                                                                                                                                        (expand
                                                                                                                                         "*")
                                                                                                                                        (("2"
                                                                                                                                          (expand
                                                                                                                                           "-")
                                                                                                                                          (("2"
                                                                                                                                            (expand
                                                                                                                                             "+")
                                                                                                                                            (("2"
                                                                                                                                              (propax)
                                                                                                                                              nil
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil)
                                                                                                                                 ("2"
                                                                                                                                  (hide-all-but
                                                                                                                                   1)
                                                                                                                                  (("2"
                                                                                                                                    (expand
                                                                                                                                     "bounded_on_int?")
                                                                                                                                    (("2"
                                                                                                                                      (inst
                                                                                                                                       +
                                                                                                                                       "1")
                                                                                                                                      (("2"
                                                                                                                                        (grind)
                                                                                                                                        nil
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil)
                                                                                                   ("2"
                                                                                                    (expand
                                                                                                     "strictly_increasing?")
                                                                                                    (("2"
                                                                                                      (inst
                                                                                                       -
                                                                                                       "x!1"
                                                                                                       "1+x!1")
                                                                                                      (("2"
                                                                                                        (assert)
                                                                                                        (("2"
                                                                                                          (ground)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil)
                                                                                   ("2"
                                                                                    (expand
                                                                                     "Intab")
                                                                                    (("2"
                                                                                      (ground)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (hide-all-but
                                                                           1)
                                                                          (("2"
                                                                            (skeep)
                                                                            (("2"
                                                                              (expand
                                                                               "bounded_on_int?")
                                                                              (("2"
                                                                                (inst
                                                                                 +
                                                                                 "1")
                                                                                (("2"
                                                                                  (grind)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (hide-all-but
                                                                       1)
                                                                      (("2"
                                                                        (skeep)
                                                                        (("2"
                                                                          (expand
                                                                           "bounded_on_int?")
                                                                          (("2"
                                                                            (inst
                                                                             +
                                                                             "1")
                                                                            (("2"
                                                                              (grind)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (case
                                                   "FORALL (xy:INTab):abs(sigfun(xy)) <= 1")
                                                  (("1"
                                                    (hide-all-but
                                                     (-1 1))
                                                    (("1"
                                                      (typepred
                                                       "fun_norm(sigfun)")
                                                      (("1"
                                                        (inst -3 "1")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (skosimp*)
                                                            (("1"
                                                              (inst
                                                               -4
                                                               "x!1")
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (hide 2)
                                                    (("2"
                                                      (skeep)
                                                      (("2"
                                                        (case
                                                         "sigfun(xy) = 0")
                                                        (("1"
                                                          (replace -1)
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (case
                                                           "FORaLL (jj:below(P`length-1)): char_fun(P`seq(jj),P`seq(1+jj))(xy) = 0")
                                                          (("1"
                                                            (expand
                                                             "sigfun"
                                                             1)
                                                            (("1"
                                                              (rewrite
                                                               "sigma_restrict_eq_0")
                                                              (("1"
                                                                (hide
                                                                 2)
                                                                (("1"
                                                                  (skeep)
                                                                  (("1"
                                                                    (inst
                                                                     -
                                                                     "i")
                                                                    (("1"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (skeep)
                                                            (("2"
                                                              (case
                                                               "sigfun(xy) = siggy`seq(jj)*char_fun(P`seq(jj), P`seq(1 + jj))(xy)")
                                                              (("1"
                                                                (replace
                                                                 -1)
                                                                (("1"
                                                                  (hide-all-but
                                                                   3)
                                                                  (("1"
                                                                    (expand
                                                                     "siggy")
                                                                    (("1"
                                                                      (grind)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (hide
                                                                 4)
                                                                (("2"
                                                                  (expand
                                                                   "sigfun"
                                                                   1)
                                                                  (("2"
                                                                    (lemma
                                                                     "sigma_split[below(P`length-1)]")
                                                                    (("2"
                                                                      (inst
                                                                       -
                                                                       "LAMBDA (nn: below(P`length - 1)):
                                                                                                         siggy`seq(nn) * char_fun(P`seq(nn), P`seq(1 + nn))(xy)"
                                                                       "P`length-2"
                                                                       "0"
                                                                       "jj")
                                                                      (("2"
                                                                        (assert)
                                                                        (("2"
                                                                          (replace
                                                                           -1)
                                                                          (("2"
                                                                            (hide
                                                                             -1)
                                                                            (("2"
                                                                              (expand
                                                                               "sigma"
                                                                               +
                                                                               1)
                                                                              (("2"
                                                                                (case
                                                                                 "sigma(0, jj - 1,
                                                                                                                                LAMBDA (nn: below(P`length - 1)):
                                                                                                                                  siggy`seq(nn) * char_fun(P`seq(nn), P`seq(1 + nn))(xy)) = 0")
                                                                                (("1"
                                                                                  (replace
                                                                                   -1)
                                                                                  (("1"
                                                                                    (hide
                                                                                     -1)
                                                                                    (("1"
                                                                                      (assert)
                                                                                      (("1"
                                                                                        (rewrite
                                                                                         "sigma_restrict_eq_0")
                                                                                        (("1"
                                                                                          (hide
                                                                                           2)
                                                                                          (("1"
                                                                                            (skeep)
                                                                                            (("1"
                                                                                              (hide-all-but
                                                                                               (1
                                                                                                2
                                                                                                -3))
                                                                                              (("1"
                                                                                                (case
                                                                                                 "a<=P`seq(jj) AND P`seq(jj) < P`seq(1+jj) AND P`seq(1+jj)<= P`seq(i) AND P`seq(i) < P`seq(1+i) AND P`seq(1+i) <= b")
                                                                                                (("1"
                                                                                                  (hide
                                                                                                   -2)
                                                                                                  (("1"
                                                                                                    (grind)
                                                                                                    nil
                                                                                                    nil))
                                                                                                  nil)
                                                                                                 ("2"
                                                                                                  (hide-all-but
                                                                                                   (-1
                                                                                                    1))
                                                                                                  (("2"
                                                                                                    (expand
                                                                                                     "strictly_increasing?")
                                                                                                    (("2"
                                                                                                      (inst-cp
                                                                                                       -
                                                                                                       "jj"
                                                                                                       "1+jj")
                                                                                                      (("2"
                                                                                                        (inst
                                                                                                         -
                                                                                                         "i"
                                                                                                         "1+i")
                                                                                                        (("2"
                                                                                                          (assert)
                                                                                                          (("2"
                                                                                                            (typepred
                                                                                                             "P")
                                                                                                            (("2"
                                                                                                              (expand
                                                                                                               "increasing?")
                                                                                                              (("2"
                                                                                                                (inst
                                                                                                                 -
                                                                                                                 "1+jj"
                                                                                                                 "i")
                                                                                                                (("2"
                                                                                                                  (assert)
                                                                                                                  (("2"
                                                                                                                    (inst-cp
                                                                                                                     -
                                                                                                                     "jj")
                                                                                                                    (("2"
                                                                                                                      (inst
                                                                                                                       -
                                                                                                                       "1+i")
                                                                                                                      (("2"
                                                                                                                        (ground)
                                                                                                                        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"
                                                                                    (rewrite
                                                                                     "sigma_restrict_eq_0")
                                                                                    (("2"
                                                                                      (hide
                                                                                       2)
                                                                                      (("2"
                                                                                        (skeep)
                                                                                        (("2"
                                                                                          (hide-all-but
                                                                                           (1
                                                                                            2
                                                                                            -3))
                                                                                          (("2"
                                                                                            (case
                                                                                             "a<=P`seq(i) AND P`seq(i) < P`seq(1+i) AND P`seq(1+i) <= P`seq(jj) AND P`seq(jj) < P`seq(jj+1) AND P`seq(jj+1) <= b")
                                                                                            (("1"
                                                                                              (hide
                                                                                               -2)
                                                                                              (("1"
                                                                                                (grind)
                                                                                                nil
                                                                                                nil))
                                                                                              nil)
                                                                                             ("2"
                                                                                              (hide-all-but
                                                                                               (-1
                                                                                                1))
                                                                                              (("2"
                                                                                                (expand
                                                                                                 "strictly_increasing?")
                                                                                                (("2"
                                                                                                  (inst-cp
                                                                                                   -
                                                                                                   "i"
                                                                                                   "1+i")
                                                                                                  (("2"
                                                                                                    (inst
                                                                                                     -
                                                                                                     "jj"
                                                                                                     "1+jj")
                                                                                                    (("2"
                                                                                                      (assert)
                                                                                                      (("2"
                                                                                                        (typepred
                                                                                                         "P")
                                                                                                        (("2"
                                                                                                          (expand
                                                                                                           "increasing?")
                                                                                                          (("2"
                                                                                                            (inst
                                                                                                             -
                                                                                                             "1+i"
                                                                                                             "jj")
                                                                                                            (("2"
                                                                                                              (inst-cp
                                                                                                               -
                                                                                                               "i")
                                                                                                              (("2"
                                                                                                                (inst
                                                                                                                 -
                                                                                                                 "1+jj")
                                                                                                                (("2"
                                                                                                                  (assert)
                                                                                                                  (("2"
                                                                                                                    (ground)
                                                                                                                    nil
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("3"
                                              (hide-all-but 1)
                                              (("3"
                                                (reveal "blem")
                                                (("3"
                                                  (flatten)
                                                  (("3"
                                                    (expand "sigfun" +)
                                                    (("3"
                                                      (inst
                                                       -
                                                       "P`length-2")
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("4"
                                              (hide-all-but 1)
                                              (("4"
                                                (reveal "blem")
                                                (("4"
                                                  (inst - "P`length-2")
                                                  (("4"
                                                    (expand "sigfun")
                                                    (("4"
                                                      (propax)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (hide 2)
                                      (("2"
                                        (induct "mm")
                                        (("1"
                                          (assert)
                                          (("1"
                                            (expand "sigma")
                                            (("1"
                                              (expand "sigma")
                                              (("1"
                                                (typepred "LB")
                                                (("1"
                                                  (expand
                                                   "bounded_linear_operator?")
                                                  (("1"
                                                    (expand
                                                     "linear_op?")
                                                    (("1"
                                                      (expand
                                                       "const_inv_op?")
                                                      (("1"
                                                        (flatten)
                                                        (("1"
                                                          (inst
                                                           -
                                                           "char_fun(P`seq(0), P`seq(1))"
                                                           "siggy`seq(0)")
                                                          (("1"
                                                            (expand
                                                             "*")
                                                            (("1"
                                                              (propax)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (skolem 1 "mm")
                                          (("2"
                                            (flatten)
                                            (("2"
                                              (assert)
                                              (("2"
                                                (expand "sigma" + 2)
                                                (("2"
                                                  (replace -2 :dir rl)
                                                  (("2"
                                                    (typepred "LB")
                                                    (("2"
                                                      (expand
                                                       "bounded_linear_operator?")
                                                      (("2"
                                                        (expand
                                                         "linear_op?")
                                                        (("2"
                                                          (flatten)
                                                          (("2"
                                                            (expand
                                                             "const_inv_op?")
                                                            (("2"
                                                              (inst
                                                               -
                                                               "char_fun(P`seq(1 + mm), P`seq(2 + mm))"
                                                               "siggy`seq(1+mm)")
                                                              (("2"
                                                                (replace
                                                                 -3
                                                                 :dir
                                                                 rl)
                                                                (("2"
                                                                  (expand
                                                                   "additive_op?")
                                                                  (("2"
                                                                    (inst
                                                                     -
                                                                     "lambda (x:INTab): sigma[below(P`length - 1)]
                                                                                (0, mm,
                                                                                 LAMBDA (nn: below(P`length - 1)):
                                                                                   siggy`seq(nn) * char_fun(P`seq(nn), P`seq(1 + nn))(x))"
                                                                     "siggy`seq(1 + mm) * char_fun(P`seq(1 + mm), P`seq(2 + mm))")
                                                                    (("1"
                                                                      (replace
                                                                       -2
                                                                       :dir
                                                                       rl)
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (case
                                                                           "(lambda (x:INTab): sigma[below(P`length - 1)]
                                                                                                                  (0, 1 + mm,
                                                                                                                   LAMBDA (nn: below(P`length - 1)):
                                                                                                                     siggy`seq(nn) * char_fun(P`seq(nn), P`seq(1 + nn))(x)))=((LAMBDA (x:INTab):
                                                                                                                sigma[below(P`length - 1)]
                                                                                                                    (0, mm,
                                                                                                                     LAMBDA (nn: below(P`length - 1)):
                                                                                                                       siggy`seq(nn) * char_fun(P`seq(nn), P`seq(1 + nn))(x)))
                                                                                                              + siggy`seq(1 + mm) * char_fun(P`seq(1 + mm), P`seq(2 + mm)))")
                                                                          (("1"
                                                                            (assert)
                                                                            nil
                                                                            nil)
                                                                           ("2"
                                                                            (hide
                                                                             2)
                                                                            (("2"
                                                                              (decompose-equality
                                                                               +)
                                                                              (("2"
                                                                                (expand
                                                                                 "+")
                                                                                (("2"
                                                                                  (expand
                                                                                   "sigma"
                                                                                   +
                                                                                   1)
                                                                                  (("2"
                                                                                    (assert)
                                                                                    (("2"
                                                                                      (expand
                                                                                       "*")
                                                                                      (("2"
                                                                                        (propax)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (hide-all-but
                                                                       1)
                                                                      (("2"
                                                                        (reveal
                                                                         "blem")
                                                                        (("2"
                                                                          (inst?)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("3"
                                          (hide-all-but 1)
                                          (("3"
                                            (skeep)
                                            (("3"
                                              (expand
                                               "bounded_on_int?")
                                              (("3"
                                                (inst + "1")
                                                (("3" (grind) nil nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("4"
                                          (reveal "blem")
                                          (("4" (propax) nil nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("3"
                                      (hide-all-but 1)
                                      (("3"
                                        (skeep)
                                        (("3"
                                          (expand "bounded_on_int?")
                                          (("3"
                                            (inst + "1")
                                            (("3" (grind) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("4"
                                      (reveal "blem")
                                      (("4" (propax) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide-all-but 1)
                                (("2"
                                  (skeep)
                                  (("2"
                                    (expand "bounded_on_int?")
                                    (("2"
                                      (inst + "mm+1")
                                      (("2"
                                        (skosimp*)
                                        (("2"
                                          (case
                                           "FORALL (rr:below(P`length-1)):abs(sigma[below(P`length - 1)]
                                                                                               (0, rr,
                                                                                                LAMBDA (nn: below(P`length - 1)):
                                                                                                  siggy`seq(nn) * char_fun(P`seq(nn), P`seq(1 + nn))(x!1)))
                                                                                        <= rr + 1")
                                          (("1" (inst - "mm"nil nil)
                                           ("2"
                                            (hide 2)
                                            (("2"
                                              (induct "rr")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (expand "sigma")
                                                  (("1"
                                                    (expand "sigma")
                                                    (("1"
                                                      (expand "siggy")
                                                      (("1"
                                                        (grind)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (skolem 1 "rr")
                                                (("2"
                                                  (flatten)
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (expand
                                                       "sigma"
                                                       +)
                                                      (("2"
                                                        (name
                                                         "CV1"
                                                         "sigma[below(P`length - 1)]
                                                                                                                   (0, rr,
                                                                                                                    LAMBDA (nn: below(P`length - 1)):
                                                                                                                      siggy`seq(nn) * char_fun(P`seq(nn), P`seq(1 + nn))(x!1))")
                                                        (("2"
                                                          (replace -1)
                                                          (("2"
                                                            (hide-all-but
                                                             (-3 +))
                                                            (("2"
                                                              (expand
                                                               "siggy")
                                                              (("2"
                                                                (grind)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("3" (hide-all-but 1)
                        (("3" (skeep)
                          (("3" (typepred "P") (("3" (assertnil nil))
                            nil))
                          nil))
                        nil)
                       ("4" (skeep) (("4" (assertnil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (hide-all-but 1)
                (("2" (skeep)
                  (("2" (expand "bounded_on_int?")
                    (("2" (inst + "1") (("2" (grind) nil nil)) nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((AND const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (INTab type-eq-decl nil riesz_interval_funs nil)
    (continuous_on_int? const-decl "bool" riesz_interval_funs nil)
    (Operator type-eq-decl nil riesz_linear_functionals nil)
    (bounded_linear_operator? const-decl "bool"
     riesz_bounded_functionals nil)
    (C_Bounded_Linear_Operator type-eq-decl nil riesz_hahn_banach nil)
    (char_fun const-decl "nnreal" riesz_representation nil)
    (nnreal type-eq-decl nil real_types nil)
    (>= const-decl "bool" reals nil)
    (B_Bounded_Linear_Operator type-eq-decl nil riesz_hahn_banach nil)
    (bounded_on_int? const-decl "bool" riesz_interval_funs nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (op_norm const-decl "{M: nnreal |
         (FORALL (f: Funs): abs(L(f)) <= M * fun_norm(f)) AND
          (FORALL (M1: real):
             M1 < M IMPLIES
              (EXISTS (f: Funs): abs(L(f)) > M1 * fun_norm(f)))}"
     riesz_bounded_functionals nil)
    (fun_norm const-decl "{M: nnreal |
         (FORALL (x): abs(f(x)) <= M) AND
          (FORALL (M1: real): M1 < M IMPLIES (EXISTS (x): abs(f(x)) > M1))}"
     riesz_interval_funs nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (bounded_op? const-decl "bool" riesz_bounded_functionals nil)
    (Continuous_Function type-eq-decl nil riesz_interval_funs nil)
    (variation_on const-decl "nnreal" bounded_variation nil)
    (strictly_increasing? const-decl "bool" sort_fseq "structures/")
    (partition type-eq-decl nil rs_partition nil)
    (below type-eq-decl nil naturalnumbers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (increasing? const-decl "bool" sort_fseq "structures/")
    (restrict const-decl "R" restrict nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (> const-decl "bool" reals nil)
    (fseq type-eq-decl nil fseqs "structures/")
    (barray type-eq-decl nil fseqs "structures/")
    (nat nonempty-type-eq-decl nil naturalnumbers 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)
    (bounded_variation? const-decl "bool" bounded_variation nil)
    (total_variation const-decl "{M: nnreal |
         (x = a IMPLIES M = 0) AND
          (x > a IMPLIES
            (FORALL (P: partition(a, x)): variation_on(a, x, P)(f) <= M))
           AND
           (FORALL (M1: nnreal):
              M1 < M IMPLIES
               (EXISTS (P: partition(a, x)):
                  variation_on(a, x, P)(f) > M1))}" bounded_variation
     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)
    (Rie_sum const-decl "real" rs_integral_def nil)
    (variation_on_strictly_sort formula-decl nil bounded_variation nil)
    (P skolem-const-decl "partition[INTab](a, b)" riesz_representation
     nil)
    (continuous? const-decl "bool" continuity_ms_def nil)
    (set type-eq-decl nil sets nil)
    (Intab const-decl "set[real]" riesz_interval_funs nil)
    (TRUE const-decl "bool" booleans nil)
    (x!1 skolem-const-decl "(LAMBDA (x: INTab[a, b]): TRUE)"
     riesz_representation nil)
    (member const-decl "bool" sets nil)
    (y!1 skolem-const-decl "(LAMBDA (x: INTab[a, b]): TRUE)"
     riesz_representation nil)
    (continuous_at? const-decl "bool" continuity_ms_def nil)
    (integral? const-decl "bool" rs_integral_def nil)
    (Riemann?_Rie formula-decl nil rs_integral_def nil)
    (xis!1 skolem-const-decl "xis?[INTab](a, b, P!1)"
     riesz_representation nil)
    (ff skolem-const-decl "Continuous_Function[a, b]"
     riesz_representation nil)
    (P!1 skolem-const-decl "partition[INTab](a, b)"
     riesz_representation nil)
    (Riemann_sum? const-decl "bool" rs_integral_def nil)
    (integral_def formula-decl nil rs_integral_def nil)
    (integrable? const-decl "bool" rs_integral_def nil)
    (RS_integrable_cont_BV formula-decl nil rs_integral_cont nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (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/")
    (sigma_restrict_eq formula-decl nil sigma "reals/")
    (P skolem-const-decl "partition[INTab](a, b)" riesz_representation
     nil)
    (restrict const-decl "[T -> real]" sigma "reals/")
    (char_fun_minus formula-decl nil riesz_representation nil)
    (minus_even_is_even application-judgement "even_int" integers nil)
    (int_times_even_is_even application-judgement "even_int" integers
     nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (odd_minus_even_is_odd application-judgement "odd_int" integers
     nil)
    (x!1 skolem-const-decl "below(P`length - 1)" riesz_representation
     nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (triangle formula-decl nil real_props nil)
    (nn skolem-const-decl "below(P`length - 1)" riesz_representation
     nil)
    (below_induction formula-decl nil bounded_nat_inductions nil)
    (pred type-eq-decl nil defined_types nil)
    (xis skolem-const-decl "xis?[INTab](a, b, P)" riesz_representation
     nil)
    (ff skolem-const-decl "Continuous_Function[a, b]"
     riesz_representation nil)
    (posreal_div_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (nnreal_plus_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (- const-decl "[T -> real]" real_fun_ops "reals/")
    (div_mult_pos_le2 formula-decl nil real_props nil)
    (nnreal_plus_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (* const-decl "[T -> real]" real_fun_ops "reals/")
    (P skolem-const-decl "partition[INTab](a, b)" riesz_representation
     nil)
    (xis skolem-const-decl "xis?[INTab](a, b, P)" riesz_representation
     nil)
    (ff!1 skolem-const-decl "Continuous_Function[a, b]"
     riesz_representation nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (+ const-decl "[T -> real]" real_fun_ops "reals/")
    (const_inv_op? const-decl "bool" riesz_linear_functionals nil)
    (minus_nzint_is_nzint application-judgement "nzint" integers nil)
    (nzint_abs_is_pos application-judgement "{j: posint | j >= i}"
     real_defs nil)
    (abs_mult formula-decl nil real_props nil)
    (additive_op? const-decl "bool" riesz_linear_functionals nil)
    (linear_op? const-decl "bool" riesz_linear_functionals nil)
    (minus_real_is_real application-judgement "real" reals nil)
    (continuous_implies_bounded formula-decl nil riesz_interval_funs
     nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (posreal_plus_nnreal_is_posreal application-judgement "posreal"
     real_types nil)
    (step_approx_def formula-decl nil riesz_representation nil)
    (partition_exists formula-decl nil rs_partition nil)
    (IFF const-decl "[bool, bool -> bool]" booleans nil)
    (member const-decl "bool" fseqs "structures/")
    (strictly_sort const-decl "{ss: fseq |
         strictly_increasing?(ss) AND
          (FORALL (x: T): member(x, s) IFF member(x, ss))}" sort_fseq
     "structures/")
    (partition_strictly_sort formula-decl nil rs_partition nil)
    (partition_union_is_strictly_sort formula-decl nil rs_partition
     nil)
    (partition_union_width formula-decl nil rs_partition nil)
    (gen_xis const-decl "xis?(a, b, P)" rs_integral_def nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (min const-decl "{p: real | p <= m AND p <= n}" real_defs nil)
    (posreal_min application-judgement
     "{z: posreal | z <= x AND z <= y}" real_defs nil)
    (abs_eq_0 formula-decl nil abs_lems "reals/")
    (nnreal_div_posreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (/= const-decl "boolean" notequal nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (LC skolem-const-decl "C_Bounded_Linear_Operator[a, b]"
     riesz_representation nil)
    (ff skolem-const-decl "Continuous_Function[a, b]"
     riesz_representation nil)
    (gg skolem-const-decl "[INTab[a, b] -> real]" riesz_representation
     nil)
    (abs_nat formula-decl nil abs_lems "reals/")
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (div_mult_pos_gt1 formula-decl nil extra_real_props nil)
    (posreal_times_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (step_approx const-decl "(bounded_on_int?[a, b])"
     riesz_representation nil)
    (width const-decl "posreal" rs_partition nil)
    (xis? type-eq-decl nil rs_integral_def nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (fun_to_op_bound formula-decl nil riesz_representation nil)
    (nnreal_times_nnreal_is_nnreal application-judgement "nnreal"
     real_types 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)
    (fun_to_op const-decl "C_Bounded_Linear_Operator"
     riesz_representation nil)
    (P!1 skolem-const-decl "partition[INTab](a, b)"
     riesz_representation nil)
    (P skolem-const-decl "partition[INTab](a, b)" riesz_representation
     nil)
    (mm skolem-const-decl "below(P`length - 1)" riesz_representation
     nil)
    (sigma_restrict_eq_0 formula-decl nil sigma "reals/")
    (int_plus_int_is_int application-judgement "int" integers nil)
    (subrange type-eq-decl nil integers nil)
    (minus_int_is_int application-judgement "int" integers nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (sigma_split formula-decl nil sigma "reals/")
    (int_abs_is_nonneg application-judgement "{j: nonneg_int | j >= i}"
     real_defs nil)
    (sigfun skolem-const-decl "[INTab[a, b] -> real]"
     riesz_representation nil)
    (sigma_nnreal application-judgement "nnreal" sigma_below "reals/")
    (x!1 skolem-const-decl "below(P`length - 1)" riesz_representation
     nil)
    (naturalnumber type-eq-decl nil naturalnumbers nil)
    (zerofun skolem-const-decl "[INTab[a, b] -> naturalnumber]"
     riesz_representation nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (siggy skolem-const-decl "[# length: int, seq: [nat -> real] #]"
     riesz_representation nil)
    (P skolem-const-decl "partition[INTab](a, b)" riesz_representation
     nil)
    (both_sides_times_pos_le1_imp formula-decl nil extra_real_props
     nil)
    (Bounded_Function type-eq-decl nil riesz_interval_funs nil)
    (odd_times_odd_is_odd application-judgement "odd_int" integers nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (sign const-decl "Sign" sign "reals/")
    (Sign type-eq-decl nil sign "reals/")
    (nzint nonempty-type-eq-decl nil integers nil)
    (default const-decl "T" fseqs "structures/")
    (Hahn_Banach formula-decl nil riesz_hahn_banach nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (a formal-const-decl "real" riesz_representation nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (< const-decl "bool" reals nil)
    (b formal-const-decl "{bb: real | a < bb}" riesz_representation
     nil))
   nil)
  (riesz_representation-1 nil 3492950416
   ("" (skeep)
    (("" (lemma "Hahn_Banach")
      (("" (inst - "LC")
        (("" (skeep -)
          ((""
            (name "gg"
                  "(LAMBDA (x:INTab): IF x = a THEN 0 ELSE LB(char_fun(a,x)) ENDIF)")
            (("1" (label "ggname" -1)
              (("1" (label "opeq" -2)
                (("1" (label "LBLC" -3)
                  (("1"
                    (case "(FORALL (P:partition(a,b)): strictly_increasing?(P) IMPLIES variation_on(a,b,P)(gg) <= op_norm[a,b,Continuous_Function[a,b]](LC))")
                    (("1" (label "VPle" -1)
                      (("1"
                        (case "total_variation(a,b,gg)(b) <= op_norm[a,b,Continuous_Function[a,b]](LC)")
                        (("1" (label "TVle" -1)
                          (("1" (inst + "gg")
                            (("1" (case "LC = fun_to_op(gg)")
                              (("1"
                                (assert)
                                (("1"
                                  (case
                                   "op_norm[a,b,Continuous_Function[a,b]](LC) <= total_variation(a,b,gg)(b)")
                                  (("1" (assertnil nil)
                                   ("2"
                                    (hide 2)
                                    (("2"
                                      (hide "TVle")
                                      (("2"
                                        (lemma "fun_to_op_bound")
                                        (("2"
                                          (typepred
                                           "op_norm[a,b,Continuous_Function[a,b]](LC)")
                                          (("2"
                                            (inst
                                             -3
                                             "total_variation(a,b,gg)(b)")
                                            (("2"
                                              (assert)
                                              (("2"
                                                (skosimp*)
                                                (("2"
                                                  (inst - "f!1")
                                                  (("2"
                                                    (inst - "f!1" "gg")
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide 2)
                                (("2"
                                  (case
                                   "FORALL (epsil:posreal,ff:Continuous_Function[a,b]): EXISTS (delta:posreal): FORALL (P:partition(a,b),xis:xis?(a,b,P)): width(a,b,P)<delta and strictly_increasing?(P) IMPLIES abs(LB(step_approx(P,xis)(ff))-fun_to_op(gg)(ff)) < epsil")
                                  (("1"
                                    (case
                                     "FORALL (ff:Continuous_Function[a,b]): LC(ff) = fun_to_op(gg)(ff)")
                                    (("1"
                                      (decompose-equality +)
                                      nil
                                      nil)
                                     ("2"
                                      (hide 2)
                                      (("2"
                                        (skeep)
                                        (("2"
                                          (case
                                           "FORALL (epsil:posreal): abs(LC(ff)-fun_to_op(gg)(ff)) < 32*epsil")
                                          (("1"
                                            (case
                                             "abs(LC(ff)-fun_to_op(gg)(ff)) = 0")
                                            (("1"
                                              (lemma "abs_eq_0")
                                              (("1"
                                                (inst?)
                                                (("1"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (hide 2)
                                              (("2"
                                                (inst
                                                 -
                                                 "abs(LC(ff)-fun_to_op(gg)(ff))/64")
                                                (("1" (assertnil nil)
                                                 ("2"
                                                  (cross-mult 1)
                                                  (("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (hide 2)
                                            (("2"
                                              (case
                                               "FORALL (epsil:posreal,ff:Continuous_Function[a,b]): EXISTS (delta:posreal): FORALL (P:partition(a,b),xis:xis?(a,b,P)):
                                                                                                                                                                                                                                                                                                             strictly_increasing?(P) AND width(a,b,P)<delta IMPLIES abs(LC(ff)-LB(step_approx(P,xis)(ff)))<epsil")
                                              (("1"
                                                (skeep)
                                                (("1"
                                                  (inst - "epsil" "ff")
                                                  (("1"
                                                    (inst
                                                     -
                                                     "epsil"
                                                     "ff")
                                                    (("1"
                                                      (skosimp*)
                                                      (("1"
                                                        (lemma
                                                         "partition_exists")
                                                        (("1"
                                                          (inst
                                                           -
                                                           "a"
                                                           "b"
                                                           "min(delta!1,delta!2)")
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (skeep -)
                                                              (("1"
                                                                (name
                                                                 "SSP"
                                                                 "strictly_sort(P)")
                                                                (("1"
                                                                  (case
                                                                   "width(a,b,SSP) < min(delta!1,delta!2)")
                                                                  (("1"
                                                                    (hide
                                                                     -2)
                                                                    (("1"
                                                                      (hide
                                                                       -2)
                                                                      (("1"
                                                                        (name
                                                                         "xis"
                                                                         "gen_xis(a,b,SSP)")
                                                                        (("1"
                                                                          (inst
                                                                           -
                                                                           "SSP"
                                                                           "xis")
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (inst
                                                                               -
                                                                               "SSP"
                                                                               "xis")
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (hide-all-but
                                                                                   (-3
                                                                                    -4
                                                                                    +))
                                                                                  (("1"
                                                                                    (grind
                                                                                     :exclude
                                                                                     ("stop_approx"
                                                                                      "fun_to_op"))
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (lemma
                                                                     "partition_union_is_strictly_sort")
                                                                    (("2"
                                                                      (inst
                                                                       -
                                                                       "a"
                                                                       "b")
                                                                      (("2"
                                                                        (assert)
                                                                        (("2"
                                                                          (inst
                                                                           -
                                                                           "P")
                                                                          (("2"
                                                                            (lemma
                                                                             "partition_union_width")
                                                                            (("2"
                                                                              (inst
                                                                               -
                                                                               "a"
                                                                               "b")
                                                                              (("2"
                                                                                (assert)
                                                                                (("2"
                                                                                  (inst
                                                                                   -
                                                                                   "P"
                                                                                   "P")
                                                                                  (("2"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("3"
                                                                    (lemma
                                                                     "partition_strictly_sort")
                                                                    (("3"
                                                                      (inst
                                                                       -
                                                                       "a"
                                                                       "b")
                                                                      (("3"
                                                                        (assert)
                                                                        (("3"
                                                                          (inst
                                                                           -
                                                                           "P")
                                                                          (("3"
                                                                            (flatten)
                                                                            (("3"
                                                                              (assert)
                                                                              (("3"
                                                                                (skosimp*)
                                                                                (("3"
                                                                                  (inst
                                                                                   -
                                                                                   "i!1")
                                                                                  (("3"
                                                                                    (ground)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (hide 2)
                                                (("2"
                                                  (skosimp*)
                                                  (("2"
                                                    (typepred "LB")
                                                    (("2"
                                                      (expand
                                                       "bounded_linear_operator?")
                                                      (("2"
                                                        (flatten)
                                                        (("2"
                                                          (expand
                                                           "bounded_op?")
                                                          (("2"
                                                            (skosimp*)
                                                            (("2"
                                                              (lemma
                                                               "step_approx_def")
                                                              (("2"
                                                                (inst
                                                                 -
                                                                 "ff!1"
                                                                 "epsil!1/(M!1+1)")
                                                                (("2"
                                                                  (skosimp*)
                                                                  (("2"
                                                                    (inst
                                                                     +
                                                                     "delta!1")
                                                                    (("2"
                                                                      (skeep)
                                                                      (("2"
                                                                        (inst
                                                                         -
                                                                         "P"
                                                                         "xis")
                                                                        (("2"
                                                                          (assert)
                                                                          (("2"
                                                                            (inst
                                                                             "LBLC"
                                                                             "ff!1")
                                                                            (("2"
                                                                              (replace
                                                                               "LBLC"
                                                                               :dir
                                                                               rl)
                                                                              (("2"
                                                                                (case
                                                                                 "LB(ff!1) - LB(step_approx(P, xis)(ff!1)) = LB(ff!1-step_approx(P,xis)(ff!1))")
                                                                                (("1"
                                                                                  (replace
                                                                                   -1)
                                                                                  (("1"
                                                                                    (inst
                                                                                     -3
                                                                                     "ff!1 - step_approx(P, xis)(ff!1)")
                                                                                    (("1"
                                                                                      (case
                                                                                       "fun_norm(ff!1 - step_approx(P, xis)(ff!1)) <= epsil!1/(M!1+1)")
                                                                                      (("1"
                                                                                        (cross-mult
                                                                                         -1)
                                                                                        (("1"
                                                                                          (assert)
                                                                                          nil
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (hide
                                                                                         2)
                                                                                        (("2"
                                                                                          (typepred
                                                                                           "fun_norm(ff!1 - step_approx(P, xis)(ff!1))")
                                                                                          (("2"
                                                                                            (inst
                                                                                             -3
                                                                                             "epsil!1/(M!1+1)")
                                                                                            (("2"
                                                                                              (assert)
                                                                                              (("2"
                                                                                                (skosimp*)
                                                                                                (("2"
                                                                                                  (inst
                                                                                                   -5
                                                                                                   "x!1")
                                                                                                  (("2"
                                                                                                    (expand
                                                                                                     "-")
                                                                                                    (("2"
                                                                                                      (assert)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (expand
                                                                                   "linear_op?")
                                                                                  (("2"
                                                                                    (flatten)
                                                                                    (("2"
                                                                                      (expand
                                                                                       "additive_op?")
                                                                                      (("2"
                                                                                        (inst
                                                                                         -
                                                                                         "ff!1"
                                                                                         "-1*step_approx(P,xis)(ff!1)")
                                                                                        (("1"
                                                                                          (expand
                                                                                           "const_inv_op?")
                                                                                          (("1"
                                                                                            (inst
                                                                                             -
                                                                                             "step_approx(P,xis)(ff!1)"
                                                                                             "-1")
                                                                                            (("1"
                                                                                              (case
                                                                                               "ff!1+-1*step_approx(P,xis)(ff!1) = ff!1-step_approx(P,xis)(ff!1)")
                                                                                              (("1"
                                                                                                (assert)
                                                                                                nil
                                                                                                nil)
                                                                                               ("2"
                                                                                                (hide-all-but
                                                                                                 1)
                                                                                                (("2"
                                                                                                  (grind
                                                                                                   :exclude
                                                                                                   ("step_approx"))
                                                                                                  (("2"
                                                                                                    (decompose-equality
                                                                                                     +)
                                                                                                    nil
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (hide-all-but
                                                                                           1)
                                                                                          (("2"
                                                                                            (typepred
                                                                                             "step_approx(P,xis)(ff!1)")
                                                                                            (("2"
                                                                                              (assert)
                                                                                              (("2"
                                                                                                (expand
                                                                                                 "*")
                                                                                                (("2"
                                                                                                  (assert)
                                                                                                  (("2"
                                                                                                    (expand
                                                                                                     "bounded_on_int?")
                                                                                                    (("2"
                                                                                                      (skosimp*)
                                                                                                      (("2"
                                                                                                        (inst
                                                                                                         +
                                                                                                         "M!2")
                                                                                                        (("2"
                                                                                                          (skosimp*)
                                                                                                          (("2"
                                                                                                            (inst
                                                                                                             -
                                                                                                             "x!1")
                                                                                                            (("2"
                                                                                                              (rewrite
                                                                                                               "abs_mult")
                                                                                                              (("2"
                                                                                                                (expand
                                                                                                                 "abs"
                                                                                                                 +
                                                                                                                 1)
                                                                                                                (("2"
                                                                                                                  (assert)
                                                                                                                  nil
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil)
                                                                                 ("3"
                                                                                  (hide-all-but
                                                                                   1)
                                                                                  (("3"
                                                                                    (expand
                                                                                     "bounded_on_int?")
                                                                                    (("3"
                                                                                      (typepred
                                                                                       "step_approx(P,xis)(ff!1)")
                                                                                      (("1"
                                                                                        (typepred
                                                                                         "ff!1")
                                                                                        (("1"
                                                                                          (lemma
                                                                                           "continuous_implies_bounded")
                                                                                          (("1"
                                                                                            (inst
                                                                                             -
                                                                                             "ff!1")
                                                                                            (("1"
                                                                                              (hide
                                                                                               -2)
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "bounded_on_int?")
                                                                                                (("1"
                                                                                                  (skosimp*)
                                                                                                  (("1"
                                                                                                    (inst
                                                                                                     +
                                                                                                     "M!2+M!3")
                                                                                                    (("1"
                                                                                                      (skosimp*)
                                                                                                      (("1"
                                                                                                        (inst
                                                                                                         -
                                                                                                         "x!1")
                                                                                                        (("1"
                                                                                                          (inst
                                                                                                           -
                                                                                                           "x!1")
                                                                                                          (("1"
                                                                                                            (grind
                                                                                                             :exclude
                                                                                                             ("step_approx"))
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (hide-all-but
                                                                                         1)
                                                                                        (("2"
                                                                                          (lemma
                                                                                           "continuous_implies_bounded")
                                                                                          (("2"
                                                                                            (inst?)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("3"
                                                (hide-all-but 1)
                                                (("3"
                                                  (skosimp*)
                                                  (("3"
                                                    (lemma
                                                     "continuous_implies_bounded")
                                                    (("3"
                                                      (inst?)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (case
                                     "FORALL (ff:Continuous_Function[a,b],P:partition(a,b),xis:xis?(a,b,P)): strictly_increasing?(P) IMPLIES LB(step_approx(P,xis)(ff)) = Rie_sum(a,b,gg,P,xis,ff)")
                                    (("1"
                                      (lemma "RS_integrable_cont_BV")
                                      (("1"
                                        (skeep)
                                        (("1"
                                          (inst - "a" "b" "ff" "gg")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (split -)
                                              (("1"
                                                (copy -1)
                                                (("1"
                                                  (expand
                                                   "integrable?"
                                                   -1)
                                                  (("1"
                                                    (skosimp*)
                                                    (("1"
                                                      (lemma
                                                       "integral_def")
                                                      (("1"
                                                        (inst
                                                         -
                                                         "a"
                                                         "b"
                                                         "ff"
                                                         "gg"
                                                         "S!1")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (case
                                                             "fun_to_op(gg)(ff) = S!1")
                                                            (("1"
                                                              (replace
                                                               -1)
                                                              (("1"
                                                                (expand
                                                                 "integral?")
                                                                (("1"
                                                                  (inst
                                                                   -
                                                                   "epsil")
                                                                  (("1"
                                                                    (skosimp*)
                                                                    (("1"
                                                                      (inst
                                                                       +
                                                                       "delta!1")
                                                                      (("1"
                                                                        (skosimp*)
                                                                        (("1"
                                                                          (inst
                                                                           -
                                                                           "P!1")
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (inst
                                                                               -
                                                                               "Rie_sum(a,b,gg,P!1,xis!1,ff)")
                                                                              (("1"
                                                                                (inst
                                                                                 -
                                                                                 "ff"
                                                                                 "P!1"
                                                                                 "xis!1")
                                                                                (("1"
                                                                                  (assert)
                                                                                  (("1"
                                                                                    (replace
                                                                                     -5)
                                                                                    (("1"
                                                                                      (hide-all-but
                                                                                       (-3
                                                                                        1))
                                                                                      (("1"
                                                                                        (grind
                                                                                         :exclude
                                                                                         "Rie_sum")
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (lemma
                                                                                 "Riemann?_Rie")
                                                                                (("2"
                                                                                  (inst
                                                                                   -
                                                                                   "a"
                                                                                   "b"
                                                                                   "ff"
                                                                                   "gg")
                                                                                  (("2"
                                                                                    (split
                                                                                     -)
                                                                                    (("1"
                                                                                      (inst
                                                                                       -
                                                                                       "P!1"
                                                                                       "xis!1")
                                                                                      nil
                                                                                      nil)
                                                                                     ("2"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (expand
                                                               "fun_to_op"
                                                               1)
                                                              (("2"
                                                                (propax)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (typepred "ff")
                                                (("2"
                                                  (hide-all-but (-1 1))
                                                  (("2"
                                                    (expand
                                                     "continuous?")
                                                    (("2"
                                                      (expand
                                                       "continuous_on_int?")
                                                      (("2"
                                                        (expand
                                                         "continuous?")
                                                        (("2"
                                                          (skosimp*)
                                                          (("2"
                                                            (inst
                                                             -
                                                             "x!1")
                                                            (("1"
                                                              (expand
                                                               "continuous_at?")
                                                              (("1"
                                                                (skosimp*)
                                                                (("1"
                                                                  (inst
                                                                   -
                                                                   "epsilon!1")
                                                                  (("1"
                                                                    (skosimp*)
                                                                    (("1"
                                                                      (inst
                                                                       +
                                                                       "delta!1")
                                                                      (("1"
                                                                        (skosimp*)
                                                                        (("1"
                                                                          (inst
                                                                           -
                                                                           "y!1")
                                                                          (("1"
                                                                            (assert)
                                                                            nil
                                                                            nil)
                                                                           ("2"
                                                                            (expand
                                                                             "Intab")
                                                                            (("2"
                                                                              (expand
                                                                               "restrict")
                                                                              (("2"
                                                                                (propax)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (expand
                                                               "Intab")
                                                              (("2"
                                                                (expand
                                                                 "restrict")
                                                                (("2"
                                                                  (propax)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("3"
                                                (expand
                                                 "bounded_variation?")
                                                (("3"
                                                  (inst
                                                   +
                                                   "op_norm[a,b,Continuous_Function[a,b]](LC)")
                                                  (("3"
                                                    (skeep)
                                                    (("3"
                                                      (inst
                                                       -
                                                       "strictly_sort(P)")
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (lemma
                                                           "variation_on_strictly_sort")
                                                          (("1"
                                                            (inst
                                                             -
                                                             "a"
                                                             "b")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (inst
                                                                 -
                                                                 "P")
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (hide-all-but
                                                         1)
                                                        (("2"
                                                          (lemma
                                                           "partition_strictly_sort")
                                                          (("2"
                                                            (inst
                                                             -
                                                             "a"
                                                             "b")
                                                            (("2"
                                                              (assert)
                                                              (("2"
                                                                (inst
                                                                 -
                                                                 "P")
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (hide 2)
                                      (("2"
                                        (hide 2)
                                        (("2"
                                          (skeep)
                                          (("2"
                                            (case
                                             "LB(step_approx(P, xis)(ff)) = sigma[below(P`length - 1)]
                                                                                                                                                                                     (0, P`length - 2,
                                                                                                                                                                                      LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                                        ff(xis`seq(n)) * LB(char_fun(P`seq(n), P`seq(1 + n))))")
                                            (("1"
                                              (replace -1)
                                              (("1"
                                                (hide -1)
                                                (("1"
                                                  (expand "Rie_sum" +)
                                                  (("1"
                                                    (rewrite
                                                     "sigma_restrict_eq")
                                                    (("1"
                                                      (hide 2)
                                                      (("1"
                                                        (decompose-equality
                                                         +)
                                                        (("1"
                                                          (expand
                                                           "restrict")
                                                          (("1"
                                                            (lemma
                                                             "char_fun_minus")
                                                            (("1"
                                                              (inst
                                                               -
                                                               "a"
                                                               "P`seq(x!1)"
                                                               "P`seq(1+x!1)")
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (case
                                                                   "a <= P`seq(x!1) AND P`seq(x!1) < P`seq(1 + x!1)")
                                                                  (("1"
                                                                    (flatten)
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (expand
                                                                         "gg"
                                                                         +)
                                                                        (("1"
                                                                          (case
                                                                           "Intab(P`seq(1+x!1)) AND Intab(P`seq(x!1))")
                                                                          (("1"
                                                                            (flatten)
                                                                            (("1"
                                                                              (assert)
                                                                              (("1"
                                                                                (lift-if)
                                                                                (("1"
                                                                                  (assert)
                                                                                  (("1"
                                                                                    (ground)
                                                                                    (("1"
                                                                                      (hide
                                                                                       1)
                                                                                      (("1"
                                                                                        (typepred
                                                                                         "LB")
                                                                                        (("1"
                                                                                          (expand
                                                                                           "bounded_linear_operator?")
                                                                                          (("1"
                                                                                            (expand
                                                                                             "linear_op?")
                                                                                            (("1"
                                                                                              (case
                                                                                               "LB(char_fun(a, P`seq(1 + x!1)) - char_fun(a, P`seq(x!1))) = LB(char_fun(a, P`seq(1 + x!1))) - LB(char_fun(a, P`seq(x!1)))")
                                                                                              (("1"
                                                                                                (assert)
                                                                                                nil
                                                                                                nil)
                                                                                               ("2"
                                                                                                (hide
                                                                                                 2)
                                                                                                (("2"
                                                                                                  (flatten)
                                                                                                  (("2"
                                                                                                    (expand
                                                                                                     "additive_op?")
                                                                                                    (("2"
                                                                                                      (inst
                                                                                                       -
                                                                                                       "char_fun(a, P`seq(1 + x!1))"
                                                                                                       "-1*char_fun(a, P`seq(x!1))")
                                                                                                      (("1"
                                                                                                        (expand
                                                                                                         "const_inv_op?")
                                                                                                        (("1"
                                                                                                          (inst
                                                                                                           -
                                                                                                           "char_fun(a,P`seq(x!1))"
                                                                                                           "-1")
                                                                                                          (("1"
                                                                                                            (case
                                                                                                             "char_fun(a, P`seq(1 + x!1)) + -1 * char_fun(a, P`seq(x!1)) = char_fun(a, P`seq(1 + x!1)) - char_fun(a, P`seq(x!1))")
                                                                                                            (("1"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil)
                                                                                                             ("2"
                                                                                                              (decompose-equality
                                                                                                               +)
                                                                                                              (("2"
                                                                                                                (expand
                                                                                                                 "-")
                                                                                                                (("2"
                                                                                                                  (expand
                                                                                                                   "+")
                                                                                                                  (("2"
                                                                                                                    (expand
                                                                                                                     "*")
                                                                                                                    (("2"
                                                                                                                      (propax)
                                                                                                                      nil
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil)
                                                                                                       ("2"
                                                                                                        (expand
                                                                                                         "bounded_on_int?")
                                                                                                        (("2"
                                                                                                          (inst
                                                                                                           +
                                                                                                           "1")
                                                                                                          (("2"
                                                                                                            (hide-all-but
                                                                                                             1)
                                                                                                            (("2"
                                                                                                              (grind)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil)
                                                                                               ("3"
                                                                                                (hide-all-but
                                                                                                 1)
                                                                                                (("3"
                                                                                                  (expand
                                                                                                   "bounded_on_int?")
                                                                                                  (("3"
                                                                                                    (inst
                                                                                                     +
                                                                                                     "2")
                                                                                                    (("3"
                                                                                                      (grind)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (hide-all-but
                                                                             1)
                                                                            (("2"
                                                                              (expand
                                                                               "Intab")
                                                                              (("2"
                                                                                (propax)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (expand
                                                                     "strictly_increasing?")
                                                                    (("2"
                                                                      (inst
                                                                       -
                                                                       "x!1"
                                                                       "1+x!1")
                                                                      (("2"
                                                                        (assert)
                                                                        (("2"
                                                                          (ground)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (hide-all-but
                                                           1)
                                                          (("2"
                                                            (skeep)
                                                            (("2"
                                                              (expand
                                                               "bounded_on_int?")
                                                              (("2"
                                                                (inst
                                                                 +
                                                                 "1")
                                                                (("2"
                                                                  (grind)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (hide 2)
                                              (("2"
                                                (expand
                                                 "step_approx"
                                                 +)
                                                (("2"
                                                  (case
                                                   "FORALL (nn:below(P`length-1)): LB(LAMBDA (x:INTab):
                                                                                                                                                   sigma[below(P`length - 1)]
                                                                                                                                                       (0, nn,
                                                                                                                                                        LAMBDA (n: below(P`length - 1)):
                                                                                                                                                          ff(xis`seq(n)) * char_fun(P`seq(n), P`seq(1 + n))(x)))
                                                                                                                                               =
                                                                                                                                               sigma[below(P`length - 1)]
                                                                                                                                                   (0, nn,
                                                                                                                                                    LAMBDA (n: below(P`length - 1)):
                                                                                                                                                      ff(xis`seq(n)) * LB(char_fun(P`seq(n), P`seq(1 + n))))")
                                                  (("1"
                                                    (inst
                                                     -
                                                     "P`length-2")
                                                    nil
                                                    nil)
                                                   ("2"
                                                    (hide 2)
                                                    (("2"
                                                      (induct "nn")
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (expand
                                                           "sigma")
                                                          (("1"
                                                            (expand
                                                             "sigma")
                                                            (("1"
                                                              (typepred
                                                               "LB")
                                                              (("1"
                                                                (expand
                                                                 "bounded_linear_operator?")
                                                                (("1"
                                                                  (expand
                                                                   "linear_op?")
                                                                  (("1"
                                                                    (expand
                                                                     "const_inv_op?")
                                                                    (("1"
                                                                      (flatten)
                                                                      (("1"
                                                                        (inst
                                                                         -
                                                                         "char_fun(P`seq(0),P`seq(1))"
                                                                         "ff(xis`seq(0))")
                                                                        (("1"
                                                                          (expand
                                                                           "*")
                                                                          (("1"
                                                                            (propax)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (skolem 1 "nn")
                                                        (("2"
                                                          (flatten)
                                                          (("2"
                                                            (expand
                                                             "sigma"
                                                             +)
                                                            (("2"
                                                              (replace
                                                               -2
                                                               :dir
                                                               rl)
                                                              (("2"
                                                                (typepred
                                                                 "LB")
                                                                (("2"
                                                                  (expand
                                                                   "bounded_linear_operator?")
                                                                  (("2"
                                                                    (expand
                                                                     "linear_op?")
                                                                    (("2"
                                                                      (expand
                                                                       "additive_op?")
                                                                      (("2"
                                                                        (flatten)
                                                                        (("2"
                                                                          (inst
                                                                           -
                                                                           "LAMBDA (x:INTab):
                                                                                                                                             sigma(0, nn,
                                                                                                                                                   LAMBDA (n: below(P`length - 1)):
                                                                                                                                                     ff(xis`seq(n)) * char_fun(P`seq(n), P`seq(1 + n))(x))"
                                                                           "LAMBDA (x:INTab):
                                                                                                                                             ff(xis`seq(1 + nn)) *
                                                                                                                                               char_fun(P`seq(1 + nn), P`seq(2 + nn))(x)")
                                                                          (("1"
                                                                            (expand
                                                                             "+")
                                                                            (("1"
                                                                              (replace
                                                                               -2)
                                                                              (("1"
                                                                                (expand
                                                                                 "const_inv_op?")
                                                                                (("1"
                                                                                  (inst
                                                                                   -
                                                                                   "char_fun(P`seq(1 + nn), P`seq(2 + nn))"
                                                                                   "ff(xis`seq(1 + nn))")
                                                                                  (("1"
                                                                                    (expand
                                                                                     "*")
                                                                                    (("1"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (hide-all-but
                                                                             1)
                                                                            (("2"
                                                                              (expand
                                                                               "bounded_on_int?")
                                                                              (("2"
                                                                                (inst
                                                                                 +
                                                                                 "abs(ff(xis`seq(1+nn)))")
                                                                                (("2"
                                                                                  (grind)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("3"
                                                                            (hide-all-but
                                                                             1)
                                                                            (("3"
                                                                              (expand
                                                                               "bounded_on_int?")
                                                                              (("3"
                                                                                (inst
                                                                                 +
                                                                                 "fun_norm(ff)*(nn+1)")
                                                                                (("1"
                                                                                  (skeep)
                                                                                  (("1"
                                                                                    (case
                                                                                     "FORALL (mm:below(nn+1)): abs(sigma[below(P`length - 1)]
                                                                                                                                                                                                              (0, mm,
                                                                                                                                                                                                               LAMBDA (n: below(P`length - 1)):
                                                                                                                                                                                                                 ff(xis`seq(n)) * char_fun(P`seq(n), P`seq(1 + n))(x_1)))
                                                                                                                                                                                                       <= fun_norm(ff) * (mm + 1)")
                                                                                    (("1"
                                                                                      (inst
                                                                                       -
                                                                                       "nn")
                                                                                      nil
                                                                                      nil)
                                                                                     ("2"
                                                                                      (hide
                                                                                       2)
                                                                                      (("2"
                                                                                        (induct
                                                                                         "mm")
                                                                                        (("1"
                                                                                          (assert)
                                                                                          (("1"
                                                                                            (expand
                                                                                             "sigma")
                                                                                            (("1"
                                                                                              (expand
                                                                                               "sigma")
                                                                                              (("1"
                                                                                                (typepred
                                                                                                 "fun_norm(ff)")
                                                                                                (("1"
                                                                                                  (inst
                                                                                                   -
                                                                                                   "xis`seq(0)")
                                                                                                  (("1"
                                                                                                    (hide
                                                                                                     -3)
                                                                                                    (("1"
                                                                                                      (grind)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (skolem
                                                                                           1
                                                                                           "mm")
                                                                                          (("2"
                                                                                            (assert)
                                                                                            (("2"
                                                                                              (flatten)
                                                                                              (("2"
                                                                                                (expand
                                                                                                 "sigma"
                                                                                                 +)
                                                                                                (("2"
                                                                                                  (lemma
                                                                                                   "triangle")
                                                                                                  (("2"
                                                                                                    (inst?)
                                                                                                    (("2"
                                                                                                      (case
                                                                                                       "abs(ff(xis`seq(1 + mm)) *
                                                                                                                                                                                                                      char_fun(P`seq(1 + mm), P`seq(2 + mm))(x_1)) <= fun_norm(ff)")
                                                                                                      (("1"
--> --------------------

--> maximum size reached

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

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

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

*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