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


Quelle  integral_step.prf

  Sprache: Lisp
 

(integral_step
 (IMP_step_fun_def_TCC1 0
  (IMP_step_fun_def_TCC1-1 nil 3282481239
   ("" (lemma "connected_domain") (("" (propax) nil nil)) nil)
   ((connected_domain formula-decl nil integral_step nil)) shostak))
 (IMP_step_fun_def_TCC2 0
  (IMP_step_fun_def_TCC2-1 nil 3282481239
   ("" (lemma "not_one_element") (("" (propax) nil nil)) nil)
   ((not_one_element formula-decl nil integral_step nil)) shostak))
 (sigma_0_m1_TCC1 0
  (sigma_0_m1_TCC1-1 nil 3403457729 ("" (subtype-tcc) nil nil)
   ((real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (sigma_0_m1_TCC2 0
  (sigma_0_m1_TCC2-1 nil 3403457729 ("" (subtype-tcc) nil nil)
   ((minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (sigma_0_m1_TCC3 0
  (sigma_0_m1_TCC3-1 nil 3403457729 ("" (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)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (integer nonempty-type-from-decl nil integers 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))
   nil))
 (sigma_0_m1 0
  (sigma_0_m1-1 nil 3403457735
   ("" (skosimp*) (("" (expand "sigma") (("" (propax) nil nil)) nil))
    nil)
   ((sigma def-decl "real" sigma "reals/")) shostak))
 (pick_TCC1 0
  (pick_TCC1-1 nil 3281791727 ("" (subtype-tcc) nil nilnil shostak))
 (pick_TCC2 0
  (pick_TCC2-1 nil 3281791727 ("" (subtype-tcc) nil nilnil shostak))
 (pick_TCC3 0
  (pick_TCC3-1 nil 3281791727 ("" (subtype-tcc) nil nilnil shostak))
 (pick_TCC4 0
  (pick_TCC4-2 nil 3281793131
   ("" (skosimp*)
    (("" (expand "nonempty?")
      (("" (expand "empty?")
        (("" (expand "member")
          (("" (inst - "(seq(P!1)(j!1) + seq(P!1)(1 + j!1))/2")
            (("1" (typepred "P!1")
              (("1" (inst - "j!1")
                (("1" (split)
                  (("1" (cross-mult 1) (("1" (assertnil nil)) nil)
                   ("2" (cross-mult 1) (("2" (assertnil nil)) nil))
                  nil))
                nil))
              nil)
             ("2" (lemma "connected_domain")
              (("2" (expand "connected?")
                (("2"
                  (inst - "seq(P!1)(j!1)" "seq(P!1)(1 + j!1)"
                   "(seq(P!1)(j!1) + seq(P!1)(1 + j!1))/2")
                  (("2" (assert)
                    (("2" (hide 2)
                      (("2" (typepred "P!1")
                        (("2" (inst - "j!1")
                          (("2" (split)
                            (("1" (cross-mult 1)
                              (("1" (assertnil nil)) nil)
                             ("2" (cross-mult 1)
                              (("2" (assertnil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nonempty? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil)
    (connected_domain formula-decl nil integral_step nil)
    (div_mult_pos_le1 formula-decl nil real_props nil)
    (div_mult_pos_le2 formula-decl nil real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (connected? const-decl "bool" deriv_domain_def nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (div_mult_pos_lt2 formula-decl nil real_props nil)
    (div_mult_pos_lt1 formula-decl nil real_props 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)
    (T_pred const-decl "[real -> boolean]" integral_step nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (/= const-decl "boolean" notequal nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (T formal-subtype-decl nil integral_step nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (a!1 skolem-const-decl "T" integral_step nil)
    (< const-decl "bool" reals nil)
    (b!1 skolem-const-decl "{x: T | a!1 < x}" integral_step nil)
    (closed_interval type-eq-decl nil intervals_real "reals/")
    (finite_sequence type-eq-decl nil finite_sequences nil)
    (> const-decl "bool" reals nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (below type-eq-decl nil naturalnumbers nil)
    (partition type-eq-decl nil integral_def nil)
    (P!1 skolem-const-decl "partition[T](a!1, b!1)" integral_step nil)
    (j!1 skolem-const-decl "below(length(P!1) - 1)" integral_step nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_div_nzreal_is_real application-judgement "real" 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)
    (empty? const-decl "bool" sets nil))
   nil)
  (pick_TCC4-1 nil 3281791727
   ("" (subtype-tcc)
    (("1" (postpone) nil nil) ("2" (postpone) nil nil)) nil)
   nil shostak))
 (stp_sect_TCC1 0
  (stp_sect_TCC1-1 nil 3262529911
   ("" (skosimp*) (("" (assertnil nil)) nil)
   ((real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   shostak))
 (stp_sect_TCC2 0
  (stp_sect_TCC2-1 nil 3262529911
   ("" (skosimp*) (("" (assertnil nil)) nil)
   ((nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   shostak))
 (stp_sect_TCC3 0
  (stp_sect_TCC3-1 nil 3262529911
   ("" (skosimp*) (("" (assertnil nil)) nil)
   ((int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   shostak))
 (stp_sect_lem_TCC1 0
  (stp_sect_lem_TCC1-1 nil 3262529911
   ("" (skosimp*) (("" (assertnil nil)) nil)
   ((real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   shostak))
 (stp_sect_lem 0
  (stp_sect_lem-1 nil 3262529850
   ("" (skosimp*)
    (("" (expand "stp_sect")
      (("" (case "x!1 = seq(P!1)(ii!1)")
        (("1" (assert)
          (("1" (lemma "parts_order")
            (("1" (inst - "a!1" "b!1" "P!1" "ii!1" "jj!1")
              (("1" (assertnil nil)) nil))
            nil))
          nil)
         ("2" (assert)
          (("2" (lift-if)
            (("2" (lemma "parts_order")
              (("2" (inst - "a!1" "b!1" "P!1" "ii!1" "jj!1")
                (("2" (assert)
                  (("2" (lemma "parts_order")
                    (("2" (inst - "a!1" "b!1" "P!1" "ii!1+1" "jj!1")
                      (("2" (assert) (("2" (ground) nil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((stp_sect const-decl "real" integral_step nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (parts_order formula-decl nil integral_def nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (T_pred const-decl "[real -> boolean]" integral_step nil)
    (T formal-subtype-decl nil integral_step nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (closed_interval type-eq-decl nil intervals_real "reals/")
    (finite_sequence type-eq-decl nil finite_sequences nil)
    (> const-decl "bool" reals nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil) (< const-decl "bool" reals nil)
    (below type-eq-decl nil naturalnumbers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (partition type-eq-decl nil integral_def nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil))
   nil))
 (sigma_stp_sect_TCC1 0
  (sigma_stp_sect_TCC1-1 nil 3262529911
   ("" (skosimp*) (("" (assertnil nil)) nil)
   ((posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers 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))
   shostak))
 (sigma_stp_sect_TCC2 0
  (sigma_stp_sect_TCC2-1 nil 3262529911
   ("" (skosimp*) (("" (assertnil nil)) nil)
   ((real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers 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))
   shostak))
 (sigma_stp_sect 0
  (sigma_stp_sect-1 nil 3262529900
   ("" (skolem!)
    (("" (assert)
      (("" (flatten)
        (("" (skolem!)
          (("" (induct "j")
            (("1" (assert)
              (("1" (flatten)
                (("1" (expand "sigma")
                  (("1" (lemma "stp_sect_lem")
                    (("1" (inst?)
                      (("1" (inst -1 "f!1" "x!1")
                        (("1" (assert)
                          (("1" (inst?)
                            (("1" (inst -1 "1")
                              (("1"
                                (assert)
                                (("1"
                                  (expand "sigma")
                                  (("1" (propax) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (skosimp*)
              (("2" (expand "sigma" 1)
                (("2" (assert)
                  (("2"
                    (case-replace "       sigma(0, j!1,
                 LAMBDA (ii: nat):
                   IF ii >= 2 + j!1 THEN 0
                   ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x!1)
                   ENDIF) =        sigma(0, j!1,
                 LAMBDA (ii: nat):
                   IF ii >= 1 + j!1 THEN 0
                   ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x!1)
                   ENDIF)")
                    (("1" (hide -1)
                      (("1" (case "x!1 > seq(P!1)(1 + j!1)")
                        (("1" (assert)
                          (("1" (replace -2)
                            (("1" (lemma "stp_sect_lem")
                              (("1"
                                (inst?)
                                (("1"
                                  (inst -1 "f!1" "x!1")
                                  (("1"
                                    (assert)
                                    (("1"
                                      (inst?)
                                      (("1"
                                        (inst - "j!1+2")
                                        (("1" (assertnil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (lemma "parts_order")
                          (("2"
                            (inst - "a!1" "b!1" "P!1" "j!1+1" "j!1+2")
                            (("2" (assertnil nil)) nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide 2)
                      (("2" (rewrite "sigma_restrict_eq[nat]")
                        (("2" (hide 2)
                          (("2" (expand "restrict")
                            (("2" (propax) nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("3" (skosimp*) nil nil)
             ("4" (skosimp*) (("4" (assertnil nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (restrict const-decl "[T -> real]" sigma "reals/")
    (sigma_restrict_eq formula-decl nil sigma "reals/")
    (parts_order formula-decl nil integral_def nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (real_gt_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)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (stp_sect_lem formula-decl nil integral_step nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (stp_sect const-decl "real" integral_step nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (sigma def-decl "real" sigma "reals/")
    (T_high type-eq-decl nil sigma "reals/")
    (T_low type-eq-decl nil sigma "reals/")
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (pred type-eq-decl nil defined_types nil)
    (x!1 skolem-const-decl "T" integral_step nil)
    (NOT const-decl "[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)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (below type-eq-decl nil nat_types nil)
    (T_pred const-decl "[real -> boolean]" integral_step nil)
    (T formal-subtype-decl nil integral_step nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (a!1 skolem-const-decl "T" integral_step nil)
    (b!1 skolem-const-decl "T" integral_step nil)
    (closed_interval type-eq-decl nil intervals_real "reals/")
    (finite_sequence type-eq-decl nil finite_sequences nil)
    (> const-decl "bool" reals nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (< const-decl "bool" reals nil)
    (below type-eq-decl nil naturalnumbers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (partition type-eq-decl nil integral_def nil)
    (P!1 skolem-const-decl "partition[T](a!1, b!1)" integral_step nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil))
   nil))
 (integral_stp_sect_TCC1 0
  (integral_stp_sect_TCC1-1 nil 3281868373 ("" (subtype-tcc) nil nil)
   nil shostak))
 (integral_stp_sect_TCC2 0
  (integral_stp_sect_TCC2-1 nil 3281868373 ("" (subtype-tcc) nil nil)
   nil shostak))
 (integral_stp_sect 0
  (integral_stp_sect-1 nil 3281796581
   ("" (skosimp*)
    (("" (rewrite "integral_def" :dir rl)
      (("1" (lemma "zero_except_intv?_integrable")
        (("1" (inst?)
          (("1" (assert)
            (("1" (assert)
              (("1"
                (inst - "val_in(a!1, b!1, P!1, j!1, f!1)"
                 "seq(P!1)(1 + j!1)" "seq(P!1)(j!1)")
                (("1" (assert)
                  (("1" (split -1)
                    (("1" (flatten) (("1" (assertnil nil)) nil)
                     ("2" (typepred "P!1")
                      (("2" (inst - "j!1"nil nil)) nil)
                     ("3" (assert)
                      (("3" (hide 2)
                        (("3" (expand "zero_except_intv?")
                          (("3" (skosimp*)
                            (("3" (assert)
                              (("3"
                                (expand "stp_sect")
                                (("3"
                                  (assert)
                                  (("3"
                                    (lift-if)
                                    (("3"
                                      (expand "val_in")
                                      (("3"
                                        (ground)
                                        (("3"
                                          (typepred "P!1")
                                          (("3"
                                            (inst - "j!1")
                                            (("3" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (assert)
        (("2" (lemma "parts_order[T]")
          (("2" (inst - "a!1" "b!1" "P!1" "0" "1+j!1")
            (("2" (assertnil nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (integral_def formula-decl nil integral_def nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (closed_interval type-eq-decl nil intervals_real "reals/")
    (finite_sequence type-eq-decl nil finite_sequences nil)
    (> const-decl "bool" reals nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (below type-eq-decl nil naturalnumbers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (partition type-eq-decl nil integral_def nil)
    (stp_sect const-decl "real" integral_step nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (val_in const-decl "real" integral_step 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)
    (T_pred const-decl "[real -> boolean]" integral_step nil)
    (T formal-subtype-decl nil integral_step nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (zero_except_intv? const-decl "bool" integral_pulse nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (zero_except_intv?_integrable formula-decl nil integral_pulse nil))
   shostak))
 (sumof_TCC1 0
  (sumof_TCC1-1 nil 3281876432 ("" (subtype-tcc) nil nilnil shostak))
 (sumof_TCC2 0
  (sumof_TCC2-1 nil 3281876432 ("" (assuming-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)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (T_pred const-decl "[real -> boolean]" integral_step nil)
    (T formal-subtype-decl nil integral_step 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)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   shostak))
 (sigma_sumof_TCC1 0
  (sigma_sumof_TCC1-1 nil 3261756014
   ("" (skosimp*) (("" (assertnil nil)) nil)
   ((nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   shostak))
 (sigma_sumof 0
  (sigma_sumof-3 nil 3306073359
   ("" (auto-rewrite "sigma_0_m1")
    (("" (skolem!)
      (("" (flatten)
        (("" (expand "step_function_on?")
          (("" (induct "n")
            (("1" (assert)
              (("1" (skosimp*)
                (("1" (expand "sumof")
                  (("1" (expand "sigma")
                    (("1" (inst - "0")
                      (("1" (skosimp*)
                        (("1" (expand "stp_sect")
                          (("1" (assert)
                            (("1" (lift-if)
                              (("1"
                                (lift-if)
                                (("1"
                                  (typepred "P!1")
                                  (("1"
                                    (inst - "0")
                                    (("1"
                                      (ground)
                                      (("1"
                                        (expand "val_in")
                                        (("1"
                                          (inst-cp
                                           -
                                           "pick(a!1, b!1, P!1, 0)")
                                          (("1"
                                            (inst - "x!1")
                                            (("1" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (typepred "P!1")
              (("2" (assert)
                (("2" (skosimp*)
                  (("2" (split -5)
                    (("1" (inst?)
                      (("1" (assert)
                        (("1" (case "x!1 <= seq(P!1)(1 + j!1)")
                          (("1" (assert)
                            (("1" (expand "sumof")
                              (("1"
                                (expand "sigma" 1)
                                (("1"
                                  (case-replace
                                   "       sigma(0, j!1,
                                                             LAMBDA (ii: nat):
                                                               IF ii > 1 + j!1 THEN 0
                                                               ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x!1)
                                                               ENDIF) =        sigma(0, j!1,
                                                             LAMBDA (ii: nat):
                                                               IF ii > j!1 THEN 0
                                                               ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x!1)
                                                               ENDIF)")
                                  (("1"
                                    (hide -1)
                                    (("1"
                                      (move-terms -2 l 2)
                                      (("1"
                                        (replace -2)
                                        (("1"
                                          (hide -2)
                                          (("1"
                                            (expand "stp_sect")
                                            (("1"
                                              (lift-if)
                                              (("1"
                                                (typepred "P!1")
                                                (("1"
                                                  (inst - "j!1+1")
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (hide 2)
                                    (("2"
                                      (rewrite
                                       "sigma_restrict_eq[nat]")
                                      (("2"
                                        (hide 2)
                                        (("2"
                                          (expand "restrict")
                                          (("2" (propax) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (assert)
                            (("2" (hide -1)
                              (("2"
                                (expand "sumof")
                                (("2"
                                  (assert)
                                  (("2"
                                    (inst - "j!1+1")
                                    (("2"
                                      (assert)
                                      (("2"
                                        (lift-if)
                                        (("2"
                                          (case-replace
                                           "x!1 = seq(P!1)(2 + j!1)")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (case-replace
                                               "(LAMBDA (ii: nat):
                                                                         IF ii > 1 + j!1 THEN 0
                                                                         ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(seq(P!1)(2 + j!1))
                                                                         ENDIF) = (LAMBDA (ii: nat): 0)")
                                              (("1"
                                                (rewrite
                                                 "sigma_const[nat]")
                                                nil
                                                nil)
                                               ("2"
                                                (hide 3)
                                                (("2"
                                                  (apply-extensionality
                                                   1
                                                   :hide?
                                                   t)
                                                  (("2"
                                                    (lift-if)
                                                    (("2"
                                                      (ground)
                                                      (("2"
                                                        (expand
                                                         "stp_sect")
                                                        (("2"
                                                          (lift-if)
                                                          (("2"
                                                            (ground)
                                                            (("1"
                                                              (lemma
                                                               "parts_order[T]")
                                                              (("1"
                                                                (inst
                                                                 -1
                                                                 "a!1"
                                                                 "b!1"
                                                                 "P!1"
                                                                 "x!2"
                                                                 "2+j!1")
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (expand
                                                               "val_in")
                                                              (("2"
                                                                (lemma
                                                                 "parts_order[T]")
                                                                (("2"
                                                                  (inst
                                                                   -1
                                                                   "a!1"
                                                                   "b!1"
                                                                   "P!1"
                                                                   "x!2+1"
                                                                   "2+j!1")
                                                                  (("2"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (assert)
                                            (("2"
                                              (lemma "sigma_stp_sect")
                                              (("2"
                                                (inst
                                                 -
                                                 "a!1"
                                                 "b!1"
                                                 "f!1"
                                                 "x!1")
                                                (("2"
                                                  (assert)
                                                  (("2"
                                                    (inst -1 "P!1")
                                                    (("2"
                                                      (expand
                                                       "sigma"
                                                       3)
                                                      (("2"
                                                        (inst -1 "j!1")
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (case-replace
                                                               "       sigma(0, j!1,
                                                                           LAMBDA (ii: nat):
                                                                             IF ii > 1 + j!1 THEN 0
                                                                             ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x!1)
                                                                             ENDIF) =        sigma(0, j!1,
                                                                           LAMBDA (ii: nat):
                                                                             IF ii >= 1 + j!1 THEN 0
                                                                             ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x!1)
                                                                             ENDIF)")
                                                              (("1"
                                                                (hide
                                                                 -1)
                                                                (("1"
                                                                  (replace
                                                                   -1)
                                                                  (("1"
                                                                    (expand
                                                                     "stp_sect")
                                                                    (("1"
                                                                      (inst
                                                                       -
                                                                       "j!1+1")
                                                                      (("1"
                                                                        (skosimp*)
                                                                        (("1"
                                                                          (inst-cp
                                                                           -
                                                                           "x!1")
                                                                          (("1"
                                                                            (expand
                                                                             "val_in")
                                                                            (("1"
                                                                              (inst
                                                                               -
                                                                               "pick(a!1, b!1, P!1, 1 + j!1)")
                                                                              (("1"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (assert)
                                                                (("2"
                                                                  (hide
                                                                   4)
                                                                  (("2"
                                                                    (rewrite
                                                                     "sigma_restrict_eq[nat]")
                                                                    (("2"
                                                                      (hide
                                                                       2)
                                                                      (("2"
                                                                        (expand
                                                                         "restrict")
                                                                        (("2"
                                                                          (propax)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (assertnil nil))
                    nil))
                  nil))
                nil))
              nil)
             ("3" (skosimp*) (("3" (assertnil nil)) nil)
             ("4" (assertnil nil)
             ("5" (skosimp*) (("5" (assertnil nil)) nil)
             ("6" (assertnil nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((step_function_on? const-decl "bool" step_fun_def nil)
    (T_high type-eq-decl nil sigma "reals/")
    (T_low type-eq-decl nil sigma "reals/")
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (IFF const-decl "[bool, bool -> bool]" booleans nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (sigma_restrict_eq formula-decl nil sigma "reals/")
    (restrict const-decl "[T -> real]" sigma "reals/")
    (sigma_const formula-decl nil sigma "reals/")
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props 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)
    (parts_order formula-decl nil integral_def nil)
    (sigma_stp_sect formula-decl nil integral_step nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (pick const-decl "{t: T | seq(P)(j) < t AND t < seq(P)(j + 1)}"
     integral_step nil)
    (open_interval type-eq-decl nil intervals_real "reals/")
    (val_in const-decl "real" integral_step nil)
    (sigma_0_m1 formula-decl nil integral_step nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (sigma def-decl "real" sigma "reals/")
    (n!1 skolem-const-decl "nat" integral_step nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (n!1 skolem-const-decl "nat" integral_step nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (stp_sect const-decl "real" integral_step nil)
    (sumof const-decl "real" integral_step nil)
    (list_of_funs type-eq-decl nil integral_step nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (below type-eq-decl nil nat_types nil)
    (T_pred const-decl "[real -> boolean]" integral_step nil)
    (T formal-subtype-decl nil integral_step nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (a!1 skolem-const-decl "T" integral_step nil)
    (< const-decl "bool" reals nil)
    (b!1 skolem-const-decl "{x: T | a!1 < x}" integral_step nil)
    (closed_interval type-eq-decl nil intervals_real "reals/")
    (finite_sequence type-eq-decl nil finite_sequences nil)
    (> const-decl "bool" reals nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (below type-eq-decl nil naturalnumbers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (partition type-eq-decl nil integral_def nil)
    (P!1 skolem-const-decl "partition[T](a!1, b!1)" integral_step nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil))
   nil)
  (sigma_sumof-2 nil 3281792634
   ("" (skolem!)
    (("" (flatten)
      (("" (expand "step_function_on?")
        (("" (induct "n")
          (("1" (assert)
            (("1" (skosimp*)
              (("1" (expand "sumof")
                (("1" (expand "sigma")
                  (("1" (inst - "0")
                    (("1" (skosimp*)
                      (("1" (expand "stp_sect")
                        (("1" (assert)
                          (("1" (lift-if)
                            (("1" (lift-if)
                              (("1"
                                (typepred "P!1")
                                (("1"
                                  (inst - "0")
                                  (("1"
                                    (ground)
                                    (("1"
                                      (expand "val_in")
                                      (("1"
                                        (inst-cp
                                         -
                                         "pick(a!1, b!1, P!1, 0)")
                                        (("1"
                                          (inst - "x!1")
                                          (("1" (assertnil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (typepred "P!1")
            (("2" (assert)
              (("2" (skosimp*)
                (("2" (split -5)
                  (("1" (inst?)
                    (("1" (assert)
                      (("1" (case "x!1 <= seq(P!1)(1 + j!1)")
                        (("1" (assert)
                          (("1" (expand "sumof")
                            (("1" (expand "sigma" 1)
                              (("1"
                                (case-replace
                                 "       sigma(0, j!1,
                                             LAMBDA (ii: nat):
                                               IF ii > 1 + j!1 THEN 0
                                               ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x!1)
                                               ENDIF) =        sigma(0, j!1,
                                             LAMBDA (ii: nat):
                                               IF ii > j!1 THEN 0
                                               ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x!1)
                                               ENDIF)")
                                (("1"
                                  (hide -1)
                                  (("1"
                                    (move-terms -2 l 2)
                                    (("1"
                                      (replace -2)
                                      (("1"
                                        (hide -2)
                                        (("1"
                                          (expand "stp_sect")
                                          (("1"
                                            (lift-if)
                                            (("1"
                                              (typepred "P!1")
                                              (("1"
                                                (inst - "j!1+1")
                                                (("1"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (skosimp*)
                                      (("2" (assertnil nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (hide 2)
                                  (("2"
                                    (rewrite "sigma_restrict_eq[nat]")
                                    (("1"
                                      (hide 2)
                                      (("1"
                                        (expand "restrict")
                                        (("1" (propax) nil nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (lemma "connected_domain")
                                      (("2"
                                        (assert)
                                        (("2"
                                          (skosimp*)
                                          (("2" (assertnil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("3"
                                  (lemma "connected_domain")
                                  (("3"
                                    (skosimp*)
                                    (("3" (assertnil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (assert)
                          (("2" (hide -1)
                            (("2" (expand "sumof")
                              (("2"
                                (assert)
                                (("2"
                                  (inst - "j!1+1")
                                  (("2"
                                    (assert)
                                    (("2"
                                      (lift-if)
                                      (("2"
                                        (case-replace
                                         "x!1 = seq(P!1)(2 + j!1)")
                                        (("1"
                                          (assert)
                                          (("1"
                                            (case-replace
                                             "(LAMBDA (ii: nat):
                                                     IF ii > 1 + j!1 THEN 0
                                                     ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(seq(P!1)(2 + j!1))
                                                     ENDIF) = (LAMBDA (ii: nat): 0)")
                                            (("1"
                                              (rewrite
                                               "sigma_const[nat]")
                                              (("1"
                                                (skosimp*)
                                                (("1"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (hide 3)
                                              (("2"
                                                (apply-extensionality
                                                 1
                                                 :hide?
                                                 t)
                                                (("2"
                                                  (lift-if)
                                                  (("2"
                                                    (ground)
                                                    (("2"
                                                      (expand
                                                       "stp_sect")
                                                      (("2"
                                                        (lift-if)
                                                        (("2"
                                                          (ground)
                                                          (("1"
                                                            (lemma
                                                             "parts_order[T]")
                                                            (("1"
                                                              (inst
                                                               -1
                                                               "a!1"
                                                               "b!1"
                                                               "P!1"
                                                               "x!2"
                                                               "2+j!1")
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (expand
                                                             "val_in")
                                                            (("2"
                                                              (lemma
                                                               "parts_order[T]")
                                                              (("2"
                                                                (inst
                                                                 -1
                                                                 "a!1"
                                                                 "b!1"
                                                                 "P!1"
                                                                 "x!2+1"
                                                                 "2+j!1")
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (assert)
                                          (("2"
                                            (lemma "sigma_stp_sect[T]")
                                            (("2"
                                              (inst
                                               -
                                               "a!1"
                                               "b!1"
                                               "f!1"
                                               "x!1")
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (inst -1 "P!1")
                                                  (("2"
                                                    (expand "sigma" 3)
                                                    (("2"
                                                      (inst -1 "j!1")
                                                      (("2"
                                                        (assert)
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (case-replace
                                                             "       sigma(0, j!1,
                                                       LAMBDA (ii: nat):
                                                         IF ii > 1 + j!1 THEN 0
                                                         ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x!1)
                                                         ENDIF) =        sigma(0, j!1,
                                                       LAMBDA (ii: nat):
                                                         IF ii >= 1 + j!1 THEN 0
                                                         ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x!1)
                                                         ENDIF)")
                                                            (("1"
                                                              (hide -1)
                                                              (("1"
                                                                (replace
                                                                 -1)
                                                                (("1"
                                                                  (expand
                                                                   "stp_sect")
                                                                  (("1"
                                                                    (inst
                                                                     -
                                                                     "j!1+1")
                                                                    (("1"
                                                                      (skosimp*)
                                                                      (("1"
                                                                        (inst-cp
                                                                         -
                                                                         "x!1")
                                                                        (("1"
                                                                          (expand
                                                                           "val_in")
                                                                          (("1"
                                                                            (inst
                                                                             -
                                                                             "pick(a!1, b!1, P!1, 1 + j!1)")
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (assert)
                                                              (("2"
                                                                (hide
                                                                 4)
                                                                (("2"
                                                                  (rewrite
                                                                   "sigma_restrict_eq[nat]")
                                                                  (("1"
                                                                    (hide
                                                                     2)
                                                                    (("1"
                                                                      (expand
                                                                       "restrict")
                                                                      (("1"
                                                                        (propax)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (lemma
                                                                     "connected_domain")
                                                                    (("2"
                                                                      (skosimp*)
                                                                      (("2"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("3"
                                                              (skosimp*)
                                                              (("3"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (assertnil nil))
                  nil))
                nil))
              nil))
            nil)
           ("3" (skosimp*) (("3" (assertnil nil)) nil)
           ("4" (assertnil nil)
           ("5" (skosimp*) (("5" (assertnil nil)) nil)
           ("6" (assertnil nil))
          nil))
        nil))
      nil))
    nil)
   ((partition type-eq-decl nil integral_def nil)
    (sigma def-decl "real" sigma "reals/")
    (parts_order formula-decl nil integral_def nil)
    (sigma_const formula-decl nil sigma "reals/")
    (restrict const-decl "[T -> real]" sigma "reals/")
    (sigma_restrict_eq formula-decl nil sigma "reals/")
    (step_function_on? const-decl "bool" step_fun_def nil))
   nil)
  (sigma_sumof-1 nil 3261754034
   ("" (skosimp*)
    (("" (expand "step_function?")
      (("" (skosimp*)
        (("" (inst + "P!1")
          (("" (induct "n")
            (("1" (assert)
              (("1" (skosimp*)
                (("1" (expand "sumof")
                  (("1" (expand "sigma")
                    (("1" (inst - "0")
                      (("1" (skosimp*)
                        (("1" (expand "stp_sect")
                          (("1" (assert)
                            (("1" (lift-if)
                              (("1"
                                (lift-if)
                                (("1"
                                  (typepred "P!1")
                                  (("1"
                                    (inst - "0")
                                    (("1"
                                      (ground)
                                      (("1"
                                        (inst-cp
                                         -
                                         "(seq(P!1)(0) + seq(P!1)(1)) / 2")
                                        (("1"
                                          (inst - "x!1")
                                          (("1" (assertnil nil))
                                          nil)
                                         ("2"
                                          (assert)
                                          (("2"
                                            (hide-all-but 1)
                                            (("2"
                                              (lemma
                                               "connected_domain")
                                              (("2"
                                                (inst?)
                                                (("2"
                                                  (inst
                                                   -
                                                   "seq(P!1)(0)"
                                                   "seq(P!1)(1)")
                                                  (("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (typepred "P!1")
              (("2" (assert)
                (("2" (skosimp*)
                  (("2" (split -5)
                    (("1" (inst?)
                      (("1" (assert)
                        (("1" (case "x!1 <= seq(P!1)(1 + j!1)")
                          (("1" (assert)
                            (("1" (expand "sumof")
                              (("1"
                                (expand "sigma" 1)
                                (("1"
                                  (case-replace
                                   "       sigma(0, j!1,
             LAMBDA (ii: nat):
               IF ii > 1 + j!1 THEN 0
               ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x!1)
               ENDIF) =        sigma(0, j!1,
             LAMBDA (ii: nat):
               IF ii > j!1 THEN 0
               ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x!1)
               ENDIF)")
                                  (("1"
                                    (hide -1)
                                    (("1"
                                      (move-terms -2 l 2)
                                      (("1"
                                        (replace -2)
                                        (("1"
                                          (hide -2)
                                          (("1"
                                            (expand "stp_sect")
                                            (("1"
                                              (lift-if)
                                              (("1"
                                                (typepred "P!1")
                                                (("1"
                                                  (inst - "j!1+1")
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (skosimp*)
                                        (("2" (assertnil nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (hide 2)
                                    (("2"
                                      (rewrite
                                       "sigma_restrict_eq[nat]")
                                      (("1"
                                        (hide 2)
                                        (("1"
                                          (expand "restrict")
                                          (("1" (propax) nil nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (skosimp*)
                                        (("2" (assertnil nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("3"
                                    (skosimp*)
                                    (("3" (assertnil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (assert)
                            (("2" (hide -1)
                              (("2"
                                (expand "sumof")
                                (("2"
                                  (assert)
                                  (("2"
                                    (inst - "j!1+1")
                                    (("2"
                                      (assert)
                                      (("2"
                                        (lift-if)
                                        (("2"
                                          (case-replace
                                           "x!1 = seq(P!1)(2 + j!1)")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (case-replace
                                               "(LAMBDA (ii: nat):
             IF ii > 1 + j!1 THEN 0
             ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(seq(P!1)(2 + j!1))
             ENDIF) = (LAMBDA (ii: nat): 0)")
                                              (("1"
                                                (rewrite
                                                 "sigma_const[nat]")
                                                (("1"
                                                  (skosimp*)
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (hide 3)
                                                (("2"
                                                  (apply-extensionality
                                                   1
                                                   :hide?
                                                   t)
                                                  (("2"
                                                    (lift-if)
                                                    (("2"
                                                      (ground)
                                                      (("2"
                                                        (expand
                                                         "stp_sect")
                                                        (("2"
                                                          (lift-if)
                                                          (("2"
                                                            (ground)
                                                            (("1"
                                                              (lemma
                                                               "parts_order")
                                                              (("1"
                                                                (inst
                                                                 -1
                                                                 "a!1"
                                                                 "b!1"
                                                                 "P!1"
                                                                 "x!2"
                                                                 "2+j!1")
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (lemma
                                                               "parts_order")
                                                              (("2"
                                                                (inst
                                                                 -1
                                                                 "a!1"
                                                                 "b!1"
                                                                 "P!1"
                                                                 "x!2+1"
                                                                 "2+j!1")
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (assert)
                                            (("2"
                                              (lemma "sigma_stp_sect")
                                              (("2"
                                                (inst
                                                 -
                                                 "a!1"
                                                 "b!1"
                                                 "f!1"
                                                 "x!1")
                                                (("2"
                                                  (assert)
                                                  (("2"
                                                    (inst -1 "P!1")
                                                    (("2"
                                                      (expand
                                                       "sigma"
                                                       3)
                                                      (("2"
                                                        (inst -1 "j!1")
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (case-replace
                                                               "       sigma(0, j!1,
             LAMBDA (ii: nat):
               IF ii > 1 + j!1 THEN 0
               ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x!1)
               ENDIF) =        sigma(0, j!1,
             LAMBDA (ii: nat):
               IF ii >= 1 + j!1 THEN 0
               ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x!1)
               ENDIF)")
                                                              (("1"
                                                                (hide
                                                                 -1)
                                                                (("1"
                                                                  (replace
                                                                   -1)
                                                                  (("1"
                                                                    (expand
                                                                     "stp_sect")
                                                                    (("1"
                                                                      (inst
                                                                       -
                                                                       "j!1+1")
                                                                      (("1"
                                                                        (skosimp*)
                                                                        (("1"
                                                                          (inst-cp
                                                                           -
                                                                           "x!1")
                                                                          (("1"
                                                                            (inst
                                                                             -
                                                                             "(seq(P!1)(1 + j!1) + seq(P!1)(2 + j!1)) / 2")
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil)
                                                                             ("2"
                                                                              (hide-all-but
                                                                               1)
                                                                              (("2"
                                                                                (lemma
                                                                                 "connected_domain")
                                                                                (("2"
                                                                                  (inst?)
                                                                                  (("2"
                                                                                    (inst
                                                                                     -
                                                                                     "seq(P!1)(1+j!1)"
                                                                                     "seq(P!1)(2+j!1)")
                                                                                    (("2"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (hide
                                                                 4)
                                                                (("2"
                                                                  (rewrite
                                                                   "sigma_restrict_eq[nat]")
                                                                  (("1"
                                                                    (hide
                                                                     2)
                                                                    (("1"
                                                                      (expand
                                                                       "restrict")
                                                                      (("1"
                                                                        (propax)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (skosimp*)
                                                                    (("2"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("3"
                                                                (skosimp*)
                                                                (("3"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (assertnil nil))
                    nil))
                  nil))
                nil))
              nil)
             ("3" (skosimp*) (("3" (assertnil nil)) nil)
             ("4" (skosimp*) (("4" (assertnil nil)) nil)
             ("5" (skosimp*) nil nil) ("6" (assertnil nil)
             ("7" (skosimp*) (("7" (assertnil nil)) nil)
             ("8" (skosimp*) (("8" (assertnil nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((sigma def-decl "real" sigma "reals/")
    (parts_order formula-decl nil integral_def nil)
    (sigma_const formula-decl nil sigma "reals/")
    (restrict const-decl "[T -> real]" sigma "reals/")
    (sigma_restrict_eq formula-decl nil sigma "reals/")
    (partition type-eq-decl nil integral_def nil))
   shostak))
 (integrable_sumof 0
  (integrable_sumof-1 nil 3281796457
   ("" (induct "n")
    (("1" (skosimp*)
      (("1" (expand "sumof")
        (("1" (expand "sigma")
          (("1" (lemma "integral_stp_sect")
            (("1" (inst?)
              (("1" (rewrite "integral_def" - :dir rl)
                (("1" (flatten)
                  (("1" (expand "stp_sect")
                    (("1" (expand "sigma") (("1" (propax) nil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil)
     ("2" (assert)
      (("2" (skosimp*)
        (("2" (expand "sumof")
          (("2" (expand "sigma" 1)
            (("2" (lemma "integral_sum")
              (("2"
                (inst - "a!1" "b!1"
                 "stp_sect(a!1, b!1, P!1, 1 + j!1, f!1)"
                 "(LAMBDA (x: T):
                                          sigma(0, j!1,
                                                LAMBDA (ii: nat):
                                                  IF ii > 1 + j!1 THEN 0
                                                  ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x)
                                                  ENDIF))")
                (("2" (assert)
                  (("2" (hide 2)
                    (("2" (lemma "integral_stp_sect")
                      (("2" (inst?)
                        (("2" (rewrite "integral_def" - :dir rl)
                          (("2" (flatten)
                            (("2"
                              (case-replace
                               "(LAMBDA x: stp_sect(a!1, b!1, P!1, 1 + j!1, f!1)(x)) = stp_sect(a!1, b!1, P!1, 1 + j!1, f!1)")
                              (("1"
                                (assert)
                                (("1"
                                  (hide -1 -2 -3)
                                  (("1"
                                    (inst?)
                                    (("1"
                                      (inst?)
                                      (("1"
                                        (case-replace
                                         "(LAMBDA x: sigma(0, j!1,
                                                                  LAMBDA (ii: nat):
                                                                    IF ii > 1 + j!1 THEN 0
                                                                    ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x)
                                                                    ENDIF)) =
                                                            (LAMBDA x: sigma(0, j!1,
                                                                  LAMBDA (ii: nat):
                                                                    IF ii > j!1 THEN 0
                                                                    ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x)
                                                                    ENDIF))")
                                        (("1" (assertnil nil)
                                         ("2"
                                          (hide -1 -2)
                                          (("2"
                                            (apply-extensionality
                                             1
                                             :hide?
                                             t)
                                            (("2"
                                              (rewrite
                                               "sigma_restrict_eq[nat]")
                                              (("2"
                                                (hide 2 3)
                                                (("2"
                                                  (expand "restrict")
                                                  (("2"
                                                    (propax)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide 2)
                                (("2"
                                  (expand "stp_sect")
                                  (("2" (propax) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((integral_sum formula-decl nil integral_prep nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (sigma_restrict_eq formula-decl nil sigma "reals/")
    (restrict const-decl "[T -> real]" sigma "reals/")
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (T_low type-eq-decl nil sigma "reals/")
    (T_high type-eq-decl nil sigma "reals/")
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (sigma def-decl "real" sigma "reals/")
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (even_plus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (integral_def formula-decl nil integral_def nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (val_in const-decl "real" integral_step nil)
    (integral_stp_sect formula-decl nil integral_step nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (stp_sect const-decl "real" integral_step nil)
    (sumof const-decl "real" integral_step nil)
    (list_of_funs type-eq-decl nil integral_step nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (integrable? const-decl "bool" integral_def nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (partition type-eq-decl nil integral_def nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (below type-eq-decl nil naturalnumbers 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)
    (finite_sequence type-eq-decl nil finite_sequences nil)
    (closed_interval type-eq-decl nil intervals_real "reals/")
    (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (below type-eq-decl nil nat_types nil)
    (< const-decl "bool" reals nil)
    (T formal-subtype-decl nil integral_step nil)
    (T_pred const-decl "[real -> boolean]" integral_step nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (int_minus_int_is_int application-judgement "int" integers nil))
   shostak))
 (integral_sumof_TCC1 0
  (integral_sumof_TCC1-1 nil 3281794545
   ("" (skosimp*)
    (("" (lemma "integrable_sumof")
      (("" (inst?) (("" (assertnil nil)) nil)) nil))
    nil)
   ((integrable_sumof formula-decl nil integral_step nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (partition type-eq-decl nil integral_def nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (below type-eq-decl nil naturalnumbers 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)
    (finite_sequence type-eq-decl nil finite_sequences nil)
    (closed_interval type-eq-decl nil intervals_real "reals/")
    (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (below type-eq-decl nil nat_types nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (T formal-subtype-decl nil integral_step nil)
    (T_pred const-decl "[real -> boolean]" integral_step nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (integral_sumof_TCC2 0
  (integral_sumof_TCC2-1 nil 3281794546
   ("" (skosimp*)
    (("" (typepred "P!1")
      (("" (lemma "parts_order")
        (("" (inst - "a!1" "b!1" "P!1" "0" "n!1+1")
          (("1" (assertnil nil) ("2" (assertnil nil)) nil))
        nil))
      nil))
    nil)
   ((partition type-eq-decl nil integral_def nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields 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)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (finite_sequence type-eq-decl nil finite_sequences nil)
    (closed_interval type-eq-decl nil intervals_real "reals/")
    (< const-decl "bool" reals nil) (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (T formal-subtype-decl nil integral_step nil)
    (T_pred const-decl "[real -> boolean]" integral_step nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (> const-decl "bool" reals 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_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (P!1 skolem-const-decl "partition[T](a!1, b!1)" integral_step nil)
    (b!1 skolem-const-decl "{x: T | a!1 < x}" integral_step nil)
    (a!1 skolem-const-decl "T" integral_step nil)
    (n!1 skolem-const-decl "nat" integral_step 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_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)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (parts_order formula-decl nil integral_def nil))
   shostak))
 (integral_sumof_TCC3 0
  (integral_sumof_TCC3-1 nil 3281794546
   ("" (subtype-tcc) (("" (postpone) nil 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)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (T_pred const-decl "[real -> boolean]" integral_step nil)
    (T formal-subtype-decl nil integral_step nil)
    (< const-decl "bool" reals nil) (> const-decl "bool" reals nil)
    (below type-eq-decl nil nat_types nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (closed_interval type-eq-decl nil intervals_real "reals/")
    (finite_sequence type-eq-decl nil finite_sequences nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (below type-eq-decl nil naturalnumbers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (partition type-eq-decl nil integral_def nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   shostak))
 (integral_sumof_TCC4 0
  (integral_sumof_TCC4-1 nil 3281794560 ("" (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)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (T_pred const-decl "[real -> boolean]" integral_step nil)
    (T formal-subtype-decl nil integral_step nil)
    (< const-decl "bool" reals nil) (> const-decl "bool" reals nil)
    (below type-eq-decl nil nat_types nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (closed_interval type-eq-decl nil intervals_real "reals/")
    (finite_sequence type-eq-decl nil finite_sequences nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (below type-eq-decl nil naturalnumbers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (partition type-eq-decl nil integral_def nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (integer nonempty-type-from-decl nil integers nil))
   shostak))
 (integral_sumof 0
  (integral_sumof-2 nil 3281870156
   ("" (induct "n")
    (("1" (skosimp*)
      (("1" (assert)
        (("1" (expand "sumof")
          (("1" (expand "sigma")
            (("1" (lemma "integral_stp_sect")
              (("1" (inst?)
                (("1" (assert)
                  (("1" (rewrite "integral_def" - :dir rl)
                    (("1" (flatten)
                      (("1" (expand "stp_sect")
                        (("1" (expand "sigma") (("1" (propax) nil nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil)
     ("2" (skosimp*)
      (("2" (expand "sumof")
        (("2" (expand "sigma" 1)
          (("2" (assert)
            (("2" (lemma "integral_sum")
              (("2"
                (inst - "a!1" "b!1"
                 "stp_sect(a!1, b!1, P!1, 1 + j!1, f!1)"
                 "(LAMBDA (x: T):
                                              sigma(0, j!1,
                                                    LAMBDA (ii: nat):
                                                      IF ii > 1 + j!1 THEN 0
                                                      ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x)
                                                      ENDIF))")
                (("2" (assert)
                  (("2" (split -1)
                    (("1" (flatten)
                      (("1" (hide -1)
                        (("1" (replace -1)
                          (("1"
                            (case-replace "(LAMBDA x: sigma(0, j!1,
                                                                          LAMBDA (ii: nat):
                                                                            IF ii > 1 + j!1 THEN 0
                                                                            ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x)
                                                                            ENDIF)) =
                                                                    (LAMBDA x: sigma(0, j!1,
                                                                          LAMBDA (ii: nat):
                                                                            IF ii > j!1 THEN 0
                                                                            ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x)
                                                                            ENDIF))")
                            (("1" (hide -1 -2)
                              (("1"
                                (inst?)
                                (("1"
                                  (assert)
                                  (("1"
                                    (replace -1)
                                    (("1"
                                      (hide -1)
                                      (("1"
                                        (lemma "integral_stp_sect")
                                        (("1"
                                          (inst?)
                                          (("1"
                                            (rewrite
                                             "integral_def"
                                             -
                                             :dir
                                             rl)
                                            (("1"
                                              (flatten)
                                              (("1"
                                                (replace -2)
                                                (("1"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (hide 2)
                              (("2"
                                (apply-extensionality 1 :hide? t)
                                (("2"
                                  (rewrite "sigma_restrict_eq[nat]")
                                  (("2"
                                    (hide 2)
                                    (("2"
                                      (expand "restrict")
                                      (("2" (propax) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide -1 2)
                      (("2" (lemma "integral_stp_sect")
                        (("2" (inst?)
                          (("2" (rewrite "integral_def" - :dir rl)
                            (("2" (flatten) nil nil)) nil))
                          nil))
                        nil))
                      nil)
                     ("3" (hide -1 2)
                      (("3" (lemma "integrable_sumof")
                        (("3" (expand "sumof")
                          (("3" (inst - "f!1" "j!1" "a!1" "b!1" "P!1")
                            (("3" (assert)
                              (("3"
                                (case-replace
                                 "(LAMBDA x: sigma(0, j!1,
                                                                          LAMBDA (ii: nat):
                                                                            IF ii > 1 + j!1 THEN 0
                                                                            ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x)
                                                                            ENDIF)) =
                                                                    (LAMBDA x: sigma(0, j!1,
                                                                          LAMBDA (ii: nat):
                                                                            IF ii > j!1 THEN 0
                                                                            ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x)
                                                                            ENDIF))")
                                (("3"
                                  (hide 2)
                                  (("3"
                                    (apply-extensionality 1 :hide? t)
                                    (("3"
                                      (rewrite
                                       "sigma_restrict_eq[nat]")
                                      (("3"
                                        (hide 2)
                                        (("3"
                                          (expand "restrict")
                                          (("3" (propax) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil)
     ("3" (skosimp*) (("3" (assertnil nil)) nil)
     ("4" (skosimp*) (("4" (assertnil nil)) nil)
     ("5" (skosimp*)
      (("5" (assert)
        (("5" (hide 2)
          (("5" (lemma "integrable_sumof")
            (("5" (inst?) (("5" (assertnil nil)) nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((integral_sum formula-decl nil integral_prep nil)
    (integrable_sumof formula-decl nil integral_step nil)
    (sigma_restrict_eq formula-decl nil sigma "reals/")
    (restrict const-decl "[T -> real]" sigma "reals/")
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (integral_stp_sect formula-decl nil integral_step nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (even_plus_odd_is_odd application-judgement "odd_int" integers nil)
    (sigma_0_neg formula-decl nil sigma_below "reals/")
    (integral_def formula-decl nil integral_def nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (finseq_appl const-decl "[below[length(fs)] -> T]" finite_sequences
     nil)
    (finseq type-eq-decl nil finite_sequences nil)
    (val_in const-decl "real" integral_step nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (sigma def-decl "real" sigma "reals/")
    (T_high type-eq-decl nil sigma "reals/")
    (T_low type-eq-decl nil sigma "reals/")
    (integral const-decl "{S: real | integral?(a, b, ff, S)}"
     integral_def nil)
    (integral? const-decl "bool" integral_def nil)
    (pred type-eq-decl nil defined_types nil)
    (integer nonempty-type-from-decl nil integers nil)
    (OR 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)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (T_pred const-decl "[real -> boolean]" integral_step nil)
    (T formal-subtype-decl nil integral_step nil)
    (< const-decl "bool" reals nil)
    (below type-eq-decl nil nat_types nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (closed_interval type-eq-decl nil intervals_real "reals/")
    (finite_sequence type-eq-decl nil finite_sequences nil)
    (> const-decl "bool" reals nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (below type-eq-decl nil naturalnumbers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (partition type-eq-decl nil integral_def nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (integrable? const-decl "bool" integral_def nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (list_of_funs type-eq-decl nil integral_step nil)
    (sumof const-decl "real" integral_step nil)
    (stp_sect const-decl "real" integral_step nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_times_real_is_real application-judgement "real" reals nil))
   nil)
  (integral_sumof-1 nil 3281795059
   ("" (induct "n")
    (("1" (skosimp*)
      (("1" (assert)
        (("1" (expand "sumof")
          (("1" (expand "sigma")
            (("1" (lemma "integral_stp_sect")
              (("1" (inst?) (("1" (assertnil nil)) nil)) nil))
            nil))
          nil))
        nil))
      nil)
     ("2" (skosimp*)
      (("2" (expand "sumof")
        (("2" (expand "sigma" 1)
          (("2" (assert)
            (("2" (lemma "integral_sum")
              (("2"
                (inst - "a!1" "seq(P!1)(2 + j!1)"
                 "stp_sect(a!1, b!1, P!1, 1 + j!1, f!1)"
                 "(LAMBDA (x: T):
                      sigma(0, j!1,
                            LAMBDA (ii: nat):
                              IF ii > 1 + j!1 THEN 0
                              ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x)
                              ENDIF))")
                (("1" (lemma "parts_order[T]")
                  (("1" (inst - "a!1" "b!1" "P!1" "0" "2+j!1")
                    (("1" (assert)
                      (("1" (rewrite "integral_def" :dir rl)
                        (("1"
                          (case-replace "(LAMBDA x: sigma(0, j!1,
                          LAMBDA (ii: nat):
                            IF ii > 1 + j!1 THEN 0
                            ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x)
                            ENDIF)) =
                    (LAMBDA x: sigma(0, j!1,
                          LAMBDA (ii: nat):
                            IF ii > j!1 THEN 0
                            ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x)
                            ENDIF))")
                          (("1" (prop)
                            (("1" (replace -2)
                              (("1"
                                (hide -1 -2 -3)
                                (("1"
                                  (case-replace
                                   "       integral(a!1, seq(P!1)(2 + j!1),
                        (LAMBDA (x: T):
                           sigma(0, j!1,
                                 LAMBDA (ii: nat):
                                   IF ii > j!1 THEN 0
                                   ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x)
                                   ENDIF))) =
               integral(a!1, seq(P!1)(1 + j!1),
                        (LAMBDA (x: T):
                           sigma(0, j!1,
                                 LAMBDA (ii: nat):
                                   IF ii > j!1 THEN 0
                                   ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x)
                                   ENDIF)))")
                                  (("1"
                                    (hide -1)
                                    (("1"
                                      (inst?)
                                      (("1"
                                        (assert)
                                        (("1"
                                          (rewrite
                                           "integral_def"
                                           -
                                           :dir
                                           rl)
                                          (("1"
                                            (flatten)
                                            (("1"
                                              (hide -2)
                                              (("1"
                                                (replace -2)
                                                (("1"
                                                  (hide -2)
                                                  (("1"
                                                    (lemma
                                                     "integral_stp_sect")
                                                    (("1"
                                                      (inst?)
                                                      (("1"
                                                        (inst
                                                         -
                                                         "seq(P!1)(2 + j!1)")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (rewrite
                                                             "integral_def"
                                                             -
                                                             :dir
                                                             rl)
                                                            (("1"
                                                              (flatten)
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (expand
                                                                   "stp_sect")
                                                                  (("1"
                                                                    (propax)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (hide 2)
                                            (("2"
                                              (lemma "parts_order[T]")
                                              (("2"
                                                (inst
                                                 -
                                                 "a!1"
                                                 "b!1"
                                                 "P!1"
                                                 "0"
                                                 "1+j!1")
                                                (("2"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("3"
                                            (skosimp*)
                                            (("3" (assertnil nil))
                                            nil)
                                           ("4"
                                            (skosimp*)
                                            (("4" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (hide 2)
                                    (("2"
                                      (hide -2)
                                      (("2"
                                        (lemma "integral_restrict_eq")
                                        (("2" (postpone) nil nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("3" (postpone) nil nil)
                                   ("4" (postpone) nil nil)
                                   ("5" (postpone) nil nil)
                                   ("6" (postpone) nil nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (postpone) nil nil)
                             ("3" (postpone) nil nil)
                             ("4" (postpone) nil nil)
                             ("5" (postpone) nil nil))
                            nil)
                           ("2" (hide 2)
                            (("2" (apply-extensionality 1 :hide? t)
                              (("1"
                                (rewrite "sigma_restrict_eq[nat]")
                                (("1"
                                  (hide 2)
                                  (("1"
                                    (expand "restrict")
                                    (("1" (propax) nil nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (skosimp*)
                                  (("2" (assertnil nil))
                                  nil))
                                nil)
                               ("2"
                                (skosimp*)
                                (("2" (assertnil nil))
                                nil))
                              nil))
                            nil)
                           ("3" (skosimp*) (("3" (assertnil nil))
                            nil))
                          nil)
                         ("2" (skosimp*) (("2" (assertnil nil)) nil)
                         ("3" (skosimp*) (("3" (assertnil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (skosimp*) (("2" (assertnil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil)
     ("3" (skosimp*) (("3" (assertnil nil)) nil)
     ("4" (skosimp*) (("4" (assertnil nil)) nil)
     ("5" (skosimp*) (("5" (assert) (("5" (postpone) nil nil)) nil))
      nil)
     ("6" (skosimp*) (("6" (assertnil nil)) nil))
    nil)
   nil shostak))
 (step_fun_is_sumof_n_TCC1 0
  (step_fun_is_sumof_n_TCC1-1 nil 3281876432 ("" (subtype-tcc) nil nil)
   ((bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (>= const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil) (> const-decl "bool" reals nil)
    (below type-eq-decl nil nat_types nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (closed_interval type-eq-decl nil intervals_real "reals/")
    (finite_sequence type-eq-decl nil finite_sequences nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (below type-eq-decl nil naturalnumbers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (partition type-eq-decl nil integral_def 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)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (T formal-subtype-decl nil integral_step nil)
    (T_pred const-decl "[real -> boolean]" integral_step 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)
    (step_function_on? const-decl "bool" step_fun_def nil))
   shostak))
 (step_fun_is_sumof_n 0
  (step_fun_is_sumof_n-1 nil 3281872825
   ("" (auto-rewrite "sigma_0_m1")
    (("" (induct "n")
      (("1" (skosimp*) (("1" (inst?) (("1" (assertnil nil)) nil))
        nil)
       ("2" (skosimp*)
        (("2" (expand "sumof")
          (("2" (assert)
            (("2" (lift-if)
              (("2" (expand "sigma")
                (("2" (ground)
                  (("2" (expand "stp_sect")
                    (("2" (lift-if)
                      (("2" (ground)
                        (("2" (expand "val_in")
                          (("2" (assert)
                            (("2" (expand "step_function_on?")
                              (("2"
                                (inst - "0")
                                (("2"
                                  (skosimp*)
                                  (("2"
                                    (inst-cp -2 "x!1")
                                    (("2"
                                      (inst
                                       -2
                                       "pick(a!1, b!1, P!1, 0)")
                                      (("2" (assertnil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("3" (skosimp*)
        (("3" (expand "sumof")
          (("3" (lift-if)
            (("3" (ground)
              (("3" (expand "sigma" 2)
                (("3" (inst?)
                  (("3" (assert)
                    (("3" (typepred "x!1")
                      (("3" (case "x!1 <= seq(P!1)(1 + j!1)")
                        (("1" (inst?)
                          (("1" (lift-if)
                            (("1" (assert)
                              (("1"
                                (ground)
                                (("1"
                                  (case-replace
                                   "       sigma(0, j!1,
                             LAMBDA (ii: nat):
                               IF ii > 1 + j!1 THEN 0
                               ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x!1)
                               ENDIF)
                 = 0")
                                  (("1"
                                    (assert)
                                    (("1"
                                      (expand "stp_sect")
                                      (("1" (propax) nil nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (hide 3)
                                    (("2"
                                      (case-replace
                                       "sigma(0, j!1,
                                LAMBDA (ii: nat):
                                  IF ii > 1 + j!1 THEN 0
                                  ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x!1)
                                  ENDIF) = sigma(0, j!1,
                                LAMBDA (ii: nat): 0)")
                                      (("1"
                                        (lemma "sigma_const[nat]")
                                        (("1"
                                          (inst?)
                                          (("1" (assertnil nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (assert)
                                        (("2"
                                          (hide 2)
                                          (("2"
                                            (rewrite
                                             "sigma_restrict_eq[nat]")
                                            (("2"
                                              (hide 2)
                                              (("2"
                                                (expand "restrict")
                                                (("2"
                                                  (apply-extensionality
                                                   1
                                                   :hide?
                                                   t)
                                                  (("2"
                                                    (lift-if)
                                                    (("2"
                                                      (ground)
                                                      (("2"
                                                        (expand
                                                         "stp_sect")
                                                        (("2"
                                                          (lift-if)
                                                          (("2"
                                                            (ground)
                                                            (("1"
                                                              (lemma
                                                               "parts_order")
                                                              (("1"
                                                                (inst
                                                                 -
                                                                 "a!1"
                                                                 "b!1"
                                                                 "P!1"
                                                                 "x!2"
                                                                 "j!1+1")
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (expand
                                                               "val_in")
                                                              (("2"
                                                                (case
                                                                 "x!2 = 1 + j!1")
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil)
                                                                 ("2"
                                                                  (assert)
                                                                  (("2"
                                                                    (lemma
                                                                     "parts_order")
                                                                    (("2"
                                                                      (inst
                                                                       -
                                                                       "a!1"
                                                                       "b!1"
                                                                       "P!1"
                                                                       "x!2+1"
                                                                       "j!1+1")
                                                                      (("2"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (case-replace
                                   "       sigma(0, j!1,
                             LAMBDA (ii: nat):
                               IF ii > 1 + j!1 THEN 0
                               ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x!1)
                               ENDIF)
                 =        sigma(0, j!1,
                             LAMBDA (ii: nat):
                               IF ii > j!1 THEN 0
                               ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x!1)
                               ENDIF)")
                                  (("1"
                                    (hide -1)
                                    (("1"
                                      (replace -1)
                                      (("1"
                                        (hide -1)
                                        (("1"
                                          (expand "stp_sect")
                                          (("1" (propax) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (hide 4)
                                    (("2"
                                      (rewrite
                                       "sigma_restrict_eq[nat]")
                                      (("2"
                                        (hide 2)
                                        (("2"
                                          (expand "restrict")
                                          (("2" (propax) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (assert)
                          (("2" (hide -4)
                            (("2" (lemma "sigma_stp_sect")
                              (("2"
                                (inst - "a!1" "b!1" "f!1" "x!1")
                                (("2"
                                  (assert)
                                  (("2"
                                    (inst - "P!1" "j!1")
                                    (("2"
                                      (assert)
                                      (("2"
                                        (assert)
                                        (("2"
                                          (case-replace
                                           "sigma(0, j!1,
                         LAMBDA (ii: nat):
                           IF ii >= 1 + j!1 THEN 0
                           ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x!1)
                           ENDIF) =
             sigma(0, j!1,
                         LAMBDA (ii: nat):
                           IF ii > 1 + j!1 THEN 0
                           ELSE stp_sect(a!1, b!1, P!1, ii, f!1)(x!1)
                           ENDIF)")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (replace -2)
                                              (("1"
                                                (hide -1 -2)
                                                (("1"
                                                  (expand
                                                   "step_function_on?")
                                                  (("1"
                                                    (inst - "j!1+1")
                                                    (("1"
                                                      (skosimp*)
                                                      (("1"
                                                        (inst-cp
                                                         -
                                                         "x!1")
                                                        (("1"
                                                          (inst
                                                           -
                                                           "pick(a!1, b!1, P!1, 1+j!1)")
                                                          (("1"
                                                            (expand
                                                             "stp_sect")
                                                            (("1"
                                                              (expand
                                                               "val_in")
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (hide -1 4)
                                            (("2"
                                              (rewrite
                                               "sigma_restrict_eq[nat]")
                                              (("2"
                                                (hide 2)
                                                (("2"
                                                  (expand "restrict")
                                                  (("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)
       ("4" (hide 2) (("4" (skosimp*) (("4" (assertnil nil)) nil))
        nil))
      nil))
    nil)
   ((nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (step_function_on? const-decl "bool" step_fun_def nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (partition type-eq-decl nil integral_def nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (below type-eq-decl nil naturalnumbers 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)
    (finite_sequence type-eq-decl nil finite_sequences nil)
    (closed_interval type-eq-decl nil intervals_real "reals/")
    (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (below type-eq-decl nil nat_types nil)
    (< const-decl "bool" reals nil)
    (T formal-subtype-decl nil integral_step nil)
    (T_pred const-decl "[real -> boolean]" integral_step nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (pred type-eq-decl nil defined_types nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (list_of_funs type-eq-decl nil integral_step nil)
    (sumof const-decl "real" integral_step nil)
    (stp_sect const-decl "real" integral_step nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (sigma_0_m1 formula-decl nil integral_step nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (val_in const-decl "real" integral_step nil)
    (pick const-decl "{t: T | seq(P)(j) < t AND t < seq(P)(j + 1)}"
     integral_step nil)
    (open_interval type-eq-decl nil intervals_real "reals/")
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (sigma def-decl "real" sigma "reals/")
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (sigma_stp_sect formula-decl nil integral_step nil)
    (a!1 skolem-const-decl "T" integral_step nil)
    (b!1 skolem-const-decl "{x: T | a!1 < x}" integral_step nil)
    (P!1 skolem-const-decl "partition[T](a!1, b!1)" integral_step nil)
    (j!1 skolem-const-decl "nat" integral_step nil)
    (x!1 skolem-const-decl "closed_interval[T](a!1, seq(P!1)(2 + j!1))"
     integral_step nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (T_high type-eq-decl nil sigma "reals/")
    (T_low type-eq-decl nil sigma "reals/")
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (int_times_even_is_even application-judgement "even_int" integers
     nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (sigma_const formula-decl nil sigma "reals/")
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (parts_order formula-decl nil integral_def nil)
    (restrict const-decl "[T -> real]" sigma "reals/")
    (sigma_restrict_eq formula-decl nil sigma "reals/"))
   shostak))
 (step_fun_is_sumof_TCC1 0
  (step_fun_is_sumof_TCC1-1 nil 3281872417
   ("" (skosimp*) (("" (assertnil nil)) nil)
   ((real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil))
   shostak))
 (step_fun_is_sumof 0
  (step_fun_is_sumof-1 nil 3281872574
   ("" (skosimp*)
    (("" (lemma "step_fun_is_sumof_n")
      (("" (inst?)
        (("" (assert)
          (("" (inst - "length(P!1)-2")
            (("" (assert)
              (("" (inst - "x!1") (("" (assertnil nil)) nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((step_fun_is_sumof_n formula-decl nil integral_step nil)
    (int_minus_int_is_int application-judgement "int" integers 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)
    (partition type-eq-decl nil integral_def nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields 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)
    (- 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)
    (finite_sequence type-eq-decl nil finite_sequences nil)
    (closed_interval type-eq-decl nil intervals_real "reals/")
    (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (T formal-subtype-decl nil integral_step nil)
    (T_pred const-decl "[real -> boolean]" integral_step nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (step_function_integrable? 0
  (step_function_integrable?-2 nil 3261749327
   ("" (skosimp*)
    (("" (expand "step_function?")
      (("" (skosimp*)
        (("" (lemma "step_fun_is_sumof")
          (("" (inst?)
            (("" (inst - "a!1" "b!1" "P!1")
              (("" (assert)
                (("" (split -1)
                  (("1" (lemma "integrable_sumof")
                    (("1" (inst?)
                      (("1" (assert)
                        (("1" (lemma "integral_restr_eq")
                          (("1"
                            (inst - "a!1" "b!1"
                             "        sumof(length(P!1) - 2,
              LAMBDA (jj: upto(length(P!1) - 2)):
                stp_sect(a!1, b!1, P!1, jj, f!1))
          WITH [b!1 := f!1(b!1)]" "f!1")
                            (("1" (assert)
                              (("1"
                                (split +)
                                (("1"
                                  (skosimp*)
                                  (("1"
                                    (inst?)
                                    (("1" (assertnil nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (hide 2)
                                  (("2"
                                    (hide -2 -4)
                                    (("2"
                                      (lemma "integral_chg_one_pt")
                                      (("2"
                                        (inst
                                         -
                                         "a!1"
                                         "b!1"
                                         "sumof(length(P!1) - 2,
              LAMBDA (jj: upto(length(P!1) - 2)):
                stp_sect(a!1, b!1, P!1, jj, f!1))"
                                         "f!1(b!1)")
                                        (("2"
                                          (assert)
                                          (("2"
                                            (inst - "b!1")
                                            (("2" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (expand "step_function_on?")
                    (("2" (propax) nil nil)) nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((step_function? const-decl "bool" step_fun_def nil)
    (step_fun_is_sumof formula-decl nil integral_step nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (integral_restr_eq formula-decl nil integral_prep nil)
    (integral_chg_one_pt formula-decl nil integral_prep nil)
    (b!1 skolem-const-decl "T" integral_step nil)
    (x!1 skolem-const-decl "T" integral_step nil)
    (a!1 skolem-const-decl "T" integral_step nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (list_of_funs type-eq-decl nil integral_step nil)
    (sumof const-decl "real" integral_step nil)
    (stp_sect const-decl "real" integral_step nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (integrable_sumof formula-decl nil integral_step nil)
    (partition type-eq-decl nil integral_def nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields 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)
    (- 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)
    (finite_sequence type-eq-decl nil finite_sequences nil)
    (closed_interval type-eq-decl nil intervals_real "reals/")
    (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (T formal-subtype-decl nil integral_step nil)
    (T_pred const-decl "[real -> boolean]" integral_step 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))
   nil)
  (step_function_integrable?-1 nil 3261494969
   ("" (skosimp*)
    (("" (lemma "step_fun_is_sumof")
      (("" (inst?)
        (("" (assert)
          (("" (skosimp*)
            (("" (replace -2 * rl)
              (("" (hide -2)
                (("" (lemma "sum_zero_excepts_integrable")
                  (("" (inst?)
                    (("" (inst -1 "n!1")
                      (("" (assert)
                        (("" (inst?) (("" (assertnil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   nil shostak))
 (step_function_on_integral_TCC1 0
  (step_function_on_integral_TCC1-1 nil 3281794562
   ("" (skosimp*)
    (("" (lemma "step_function_integrable?")
      (("" (inst?)
        (("" (assert)
          (("" (expand "step_function?") (("" (inst?) nil nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((step_function_integrable? formula-decl nil integral_step nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (partition type-eq-decl nil integral_def nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (below type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals 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)
    (- 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)
    (finite_sequence type-eq-decl nil finite_sequences nil)
    (closed_interval type-eq-decl nil intervals_real "reals/")
    (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (step_function? const-decl "bool" step_fun_def nil)
    (T formal-subtype-decl nil integral_step nil)
    (T_pred const-decl "[real -> boolean]" integral_step nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (step_function_on_integral_TCC2 0
  (step_function_on_integral_TCC2-1 nil 3281794594
   ("" (subtype-tcc) nil nil)
   ((bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (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)
    (partition type-eq-decl nil integral_def nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (below type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals 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)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (finite_sequence type-eq-decl nil finite_sequences nil)
    (closed_interval type-eq-decl nil intervals_real "reals/")
    (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (> const-decl "bool" reals nil)
    (T formal-subtype-decl nil integral_step nil)
    (T_pred const-decl "[real -> boolean]" integral_step 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)
    (step_function_on? const-decl "bool" step_fun_def nil))
   shostak))
 (step_function_on_integral_TCC3 0
  (step_function_on_integral_TCC3-1 nil 3281794594
   ("" (subtype-tcc) nil nil)
   ((bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (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)
    (partition type-eq-decl nil integral_def nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (below type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals 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)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (finite_sequence type-eq-decl nil finite_sequences nil)
    (closed_interval type-eq-decl nil intervals_real "reals/")
    (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (> const-decl "bool" reals nil)
    (T formal-subtype-decl nil integral_step nil)
    (T_pred const-decl "[real -> boolean]" integral_step 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)
    (step_function_on? const-decl "bool" step_fun_def nil))
   shostak))
 (step_function_on_integral_TCC4 0
  (step_function_on_integral_TCC4-1 nil 3281794594
   ("" (subtype-tcc) nil nil)
   ((bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (partition type-eq-decl nil integral_def nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (below type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals 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)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (finite_sequence type-eq-decl nil finite_sequences nil)
    (closed_interval type-eq-decl nil intervals_real "reals/")
    (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (> const-decl "bool" reals nil)
    (T formal-subtype-decl nil integral_step nil)
    (T_pred const-decl "[real -> boolean]" integral_step 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)
    (step_function_on? const-decl "bool" step_fun_def nil))
   shostak))
 (step_function_on_integral_TCC5 0
  (step_function_on_integral_TCC5-1 nil 3281794594
   ("" (subtype-tcc) nil nil)
   ((bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (partition type-eq-decl nil integral_def nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (below type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals 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)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (finite_sequence type-eq-decl nil finite_sequences nil)
    (closed_interval type-eq-decl nil intervals_real "reals/")
    (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (> const-decl "bool" reals nil)
    (T formal-subtype-decl nil integral_step nil)
    (T_pred const-decl "[real -> boolean]" integral_step 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)
    (step_function_on? const-decl "bool" step_fun_def nil))
   shostak))
 (step_function_on_integral_TCC6 0
  (step_function_on_integral_TCC6-1 nil 3281794594
   ("" (subtype-tcc) nil nil)
   ((bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (partition type-eq-decl nil integral_def nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (below type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals 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)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (finite_sequence type-eq-decl nil finite_sequences nil)
    (closed_interval type-eq-decl nil intervals_real "reals/")
    (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (> const-decl "bool" reals nil)
    (T formal-subtype-decl nil integral_step nil)
    (T_pred const-decl "[real -> boolean]" integral_step 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)
    (step_function_on? const-decl "bool" step_fun_def nil))
   shostak))
 (step_function_on_integral_TCC7 0
  (step_function_on_integral_TCC7-1 nil 3281794594
   ("" (assuming-tcc) nil nil)
   ((bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans 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)
    (real_ge_is_total_order name-judgement "(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)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (integer nonempty-type-from-decl nil integers nil)
    (partition type-eq-decl nil integral_def nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (below type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals 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)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (finite_sequence type-eq-decl nil finite_sequences nil)
    (closed_interval type-eq-decl nil intervals_real "reals/")
    (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (> const-decl "bool" reals nil)
    (T formal-subtype-decl nil integral_step nil)
    (T_pred const-decl "[real -> boolean]" integral_step 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)
    (step_function_on? const-decl "bool" step_fun_def nil))
   shostak))
 (step_function_on_integral 0
  (step_function_on_integral-1 nil 3281871787
   ("" (skosimp*)
    (("" (assert)
      (("" (lemma "step_fun_is_sumof")
        (("" (inst - "f!1" "a!1" "b!1" "P!1")
          (("" (assert)
            (("" (lemma "integral_sumof")
              (("" (inst?)
                (("" (assert)
                  (("" (replace -1 * rl)
                    (("" (hide -1)
                      (("" (lemma "integral_chg_one_pt")
                        ((""
                          (inst - "a!1" "b!1" "sumof(length(P!1) - 2,
                        LAMBDA (jj: upto(length(P!1) - 2)):
                          stp_sect(a!1, b!1, P!1, jj, f!1))"
                           "f!1(b!1)")
                          (("" (assert)
                            (("" (inst - "b!1")
                              ((""
                                (assert)
                                ((""
                                  (lemma "integrable_sumof")
                                  ((""
                                    (inst?)
                                    ((""
                                      (assert)
                                      ((""
                                        (flatten)
                                        ((""
                                          (replace -3)
                                          ((""
                                            (hide -3)
                                            ((""
                                              (lemma
                                               "integral_restr_eq")
                                              ((""
                                                (inst
                                                 -
                                                 "a!1"
                                                 "b!1"
                                                 "        sumof(length(P!1) - 2,
                    LAMBDA (jj: upto(length(P!1) - 2)):
                      stp_sect(a!1, b!1, P!1, jj, f!1))
                WITH [b!1 := f!1(b!1)]"
                                                 "f!1")
                                                ((""
                                                  (assert)
                                                  ((""
                                                    (hide 2)
                                                    ((""
                                                      (skosimp*)
                                                      ((""
                                                        (assert)
                                                        ((""
                                                          (inst?)
                                                          ((""
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (AND const-decl "[bool, 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)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (T_pred const-decl "[real -> boolean]" integral_step nil)
    (T formal-subtype-decl nil integral_step nil)
    (<= const-decl "bool" reals nil)
    (closed_interval type-eq-decl nil intervals_real "reals/")
    (finite_sequence type-eq-decl nil finite_sequences nil)
    (> const-decl "bool" reals nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil)
    (below type-eq-decl nil naturalnumbers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (partition type-eq-decl nil integral_def nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (real_times_real_is_real application-judgement "real" reals 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)
    (finseq_appl const-decl "[below[length(fs)] -> T]" finite_sequences
     nil)
    (integral_sumof formula-decl nil integral_step nil)
    (stp_sect const-decl "real" integral_step nil)
    (sumof const-decl "real" integral_step nil)
    (list_of_funs type-eq-decl nil integral_step nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (integrable_sumof formula-decl nil integral_step nil)
    (integral_restr_eq formula-decl nil integral_prep nil)
    (integral_chg_one_pt formula-decl nil integral_prep nil)
    (step_fun_is_sumof formula-decl nil integral_step nil))
   shostak))
 (step_to_integrable 0
  (step_to_integrable-2 nil 3278425755
   ("" (skosimp*)
    (("" (lemma "integrable_lem")
      (("" (inst?)
        (("" (assert)
          (("" (skosimp*)
            (("" (inst - "epsi!1/3")
              (("" (skosimp*)
                (("" (lemma "step_function_integrable?")
                  (("" (inst-cp -1 "a!1" "b!1" "f2!1")
                    (("" (inst -1 "a!1" "b!1" "f1!1")
                      (("" (assert)
                        (("" (expand "integrable?" -)
                          (("" (skosimp*)
                            ((""
                              (case "integral(a!1, b!1, f1!1) = S!1")
                              (("1"
                                (case "integral(a!1, b!1, f2!1) = S!2")
                                (("1"
                                  (expand "integral?")
                                  (("1"
                                    (inst -3 "epsi!1/3")
                                    (("1"
                                      (inst -4 "epsi!1/3")
                                      (("1"
                                        (skosimp*)
                                        (("1"
                                          (name
                                           "DEL"
                                           "IF delta!1 <= delta!2 THEN delta!1 ELSE delta!2 ENDIF")
                                          (("1"
                                            (case
                                             "FORALL (P: partition[T](a!1, b!1), xis: (xis?(a!1,b!1,P))):                 width(a!1, b!1, P) < DEL IMPLIES         S!1-epsi!1/3 < Rie_sum(a!1, b!1, P, xis, f!1) AND         Rie_sum(a!1, b!1, P, xis, f!1) < S!2+epsi!1/3")
                                            (("1"
                                              (inst + "DEL")
                                              (("1"
                                                (skosimp*)
                                                (("1"
                                                  (typepred "RS1!1")
                                                  (("1"
                                                    (expand
                                                     "Riemann_sum?")
                                                    (("1"
                                                      (skosimp*)
                                                      (("1"
                                                        (replace -1)
                                                        (("1"
                                                          (hide -1)
                                                          (("1"
                                                            (typepred
                                                             "RS2!1")
                                                            (("1"
                                                              (expand
                                                               "Riemann_sum?")
                                                              (("1"
                                                                (skosimp*)
                                                                (("1"
                                                                  (replace
                                                                   -1)
                                                                  (("1"
                                                                    (hide
                                                                     -1)
                                                                    (("1"
                                                                      (inst-cp
                                                                       -1
                                                                       "P1!1"
                                                                       "xis!1")
                                                                      (("1"
                                                                        (inst
                                                                         -1
                                                                         "P2!1"
                                                                         "xis!2")
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (lemma
                                                                             "integral_diff")
                                                                            (("1"
                                                                              (inst
                                                                               -1
                                                                               "a!1"
                                                                               "b!1"
                                                                               "f2!1"
                                                                               "f1!1")
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (flatten)
                                                                                  (("1"
                                                                                    (case-replace
                                                                                     "(LAMBDA x: f2!1(x) - f1!1(x)) = f2!1 - f1!1")
                                                                                    (("1"
                                                                                      (hide
                                                                                       -1)
                                                                                      (("1"
                                                                                        (replace
                                                                                         -2)
                                                                                        (("1"
                                                                                          (hide
                                                                                           -16
                                                                                           -17)
                                                                                          (("1"
                                                                                            (hide
                                                                                             -1
                                                                                             -2)
                                                                                            (("1"
                                                                                              (name-replace
                                                                                               rsum1
                                                                                               "Rie_sum(a!1, b!1, P1!1, xis!1, f!1)")
                                                                                              (("1"
                                                                                                (name-replace
                                                                                                 rsum2
                                                                                                 "Rie_sum(a!1, b!1, P2!1, xis!2, f!1)")
                                                                                                (("1"
                                                                                                  (replace
                                                                                                   -6)
                                                                                                  (("1"
                                                                                                    (hide
                                                                                                     -6)
                                                                                                    (("1"
                                                                                                      (replace
                                                                                                       -6)
                                                                                                      (("1"
                                                                                                        (hide
                                                                                                         -6)
                                                                                                        (("1"
                                                                                                          (hide
                                                                                                           -5
                                                                                                           -6
                                                                                                           -7
                                                                                                           -8
                                                                                                           -9
                                                                                                           -10
                                                                                                           -11
                                                                                                           2)
                                                                                                          (("1"
                                                                                                            (hide
                                                                                                             -5)
                                                                                                            (("1"
                                                                                                              (grind)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (hide-all-but
                                                                                       1)
                                                                                      (("2"
                                                                                        (expand
                                                                                         "-")
                                                                                        (("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)
                                             ("2"
                                              (hide 2)
                                              (("2"
                                                (skosimp*)
                                                (("2"
                                                  (inst -5 "P!1")
                                                  (("2"
                                                    (inst -6 "P!1")
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (split -5)
                                                        (("1"
                                                          (split -6)
                                                          (("1"
                                                            (inst
                                                             -
                                                             "Rie_sum(a!1, b!1, P!1, xis!1, f2!1)")
                                                            (("1"
                                                              (inst
                                                               -
                                                               "Rie_sum(a!1, b!1, P!1, xis!1, f1!1)")
                                                              (("1"
                                                                (hide
                                                                 -3
                                                                 -4)
                                                                (("1"
                                                                  (hide
                                                                   -3
                                                                   -4
                                                                   -5
                                                                   -6)
                                                                  (("1"
                                                                    (case
                                                                     "Rie_sum(a!1, b!1, P!1, xis!1, f1!1) <= Rie_sum(a!1, b!1, P!1, xis!1, f!1)")
                                                                    (("1"
                                                                      (case
                                                                       "Rie_sum(a!1, b!1, P!1, xis!1, f!1) <= Rie_sum(a!1, b!1, P!1, xis!1, f2!1)")
                                                                      (("1"
                                                                        (hide
                                                                         -5
                                                                         -6)
                                                                        (("1"
                                                                          (hide
                                                                           -5
                                                                           2)
                                                                          (("1"
                                                                            (grind
                                                                             :exclude
                                                                             "Rie_sum")
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (hide
                                                                         -1
                                                                         -2
                                                                         -3
                                                                         -4
                                                                         -6
                                                                         -7
                                                                         2
                                                                         3)
                                                                        (("2"
                                                                          (expand
                                                                           "Rie_sum")
                                                                          (("2"
                                                                            (assert)
                                                                            (("2"
                                                                              (lemma
                                                                               "sigma[below(length(P!1)-1)].sigma_le")
                                                                              (("1"
                                                                                (inst?)
                                                                                (("1"
                                                                                  (assert)
                                                                                  (("1"
                                                                                    (hide
                                                                                     2)
                                                                                    (("1"
                                                                                      (skosimp*)
                                                                                      (("1"
                                                                                        (factor
                                                                                         1
                                                                                         l)
                                                                                        (("1"
                                                                                          (factor
                                                                                           1
                                                                                           r)
                                                                                          (("1"
                                                                                            (name
                                                                                             "DD"
                                                                                             "(seq(P!1)(n!1+1) - seq(P!1)(n!1))")
                                                                                            (("1"
                                                                                              (replace
                                                                                               -1)
                                                                                              (("1"
                                                                                                (inst?)
                                                                                                (("1"
                                                                                                  (flatten)
                                                                                                  (("1"
                                                                                                    (mult-by
                                                                                                     -3
                                                                                                     "DD")
                                                                                                    (("1"
                                                                                                      (typepred
                                                                                                       "xis!1")
                                                                                                      (("1"
                                                                                                        (assert)
                                                                                                        (("1"
                                                                                                          (inst?)
                                                                                                          (("1"
                                                                                                            (lemma
                                                                                                             "parts_order")
                                                                                                            (("1"
                                                                                                              (inst
                                                                                                               -
                                                                                                               "a!1"
                                                                                                               "b!1"
                                                                                                               "P!1"
                                                                                                               "n!1"
                                                                                                               "n!1+1")
                                                                                                              (("1"
                                                                                                                (assert)
                                                                                                                nil
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (typepred
                                                                                 "xis!1")
                                                                                (("2"
                                                                                  (hide
                                                                                   2)
                                                                                  (("2"
                                                                                    (skosimp*)
                                                                                    (("2"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (expand
                                                                       "Rie_sum")
                                                                      (("2"
                                                                        (assert)
                                                                        (("2"
                                                                          (hide
                                                                           2
                                                                           3)
                                                                          (("2"
                                                                            (lemma
                                                                             "sigma[below(length(P!1)-1)].sigma_le")
                                                                            (("1"
                                                                              (inst?)
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (hide
                                                                                   2)
                                                                                  (("1"
                                                                                    (skosimp*)
                                                                                    (("1"
                                                                                      (factor
                                                                                       1
                                                                                       l)
                                                                                      (("1"
                                                                                        (factor
                                                                                         1
                                                                                         r)
                                                                                        (("1"
                                                                                          (name
                                                                                           "DD"
                                                                                           "(seq(P!1)(n!1+1) - seq(P!1)(n!1))")
                                                                                          (("1"
                                                                                            (replace
                                                                                             -1)
                                                                                            (("1"
                                                                                              (inst?)
                                                                                              (("1"
                                                                                                (flatten)
                                                                                                (("1"
                                                                                                  (mult-by
                                                                                                   -5
                                                                                                   "DD")
                                                                                                  (("1"
                                                                                                    (typepred
                                                                                                     "xis!1")
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      (("1"
                                                                                                        (hide-all-but
                                                                                                         (-1
                                                                                                          1
                                                                                                          2))
                                                                                                        (("1"
                                                                                                          (lemma
                                                                                                           "parts_order")
                                                                                                          (("1"
                                                                                                            (inst
                                                                                                             -1
                                                                                                             "a!1"
                                                                                                             "b!1"
                                                                                                             "P!1"
                                                                                                             "n!1"
                                                                                                             "n!1+1")
                                                                                                            (("1"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (skosimp*)
                                                                              (("2"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (hide-all-but
                                                                 (-1
                                                                  1))
                                                                (("2"
                                                                  (lemma
                                                                   "Riemann?_Rie")
                                                                  (("2"
                                                                    (inst
                                                                     -
                                                                     "a!1"
                                                                     "b!1"
                                                                     "f1!1")
                                                                    (("2"
                                                                      (split
                                                                       -1)
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (inst
                                                                           -1
                                                                           "P!1"
                                                                           "xis!1")
                                                                          nil
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (hide-all-but
                                                               1)
                                                              (("2"
                                                                (lemma
                                                                 "Riemann?_Rie")
                                                                (("2"
                                                                  (inst
                                                                   -
                                                                   "a!1"
                                                                   "b!1"
                                                                   "f2!1")
                                                                  (("2"
                                                                    (split
                                                                     -1)
                                                                    (("1"
                                                                      (inst
                                                                       -1
                                                                       "P!1"
                                                                       "xis!1")
                                                                      nil
                                                                      nil)
                                                                     ("2"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (hide
                                                             -1
                                                             -4
                                                             -5
                                                             -6
                                                             -7
                                                             -8
                                                             -9
                                                             -10
                                                             2
                                                             3)
                                                            (("2"
                                                              (grind
                                                               :exclude
                                                               "width")
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (hide
                                                           -3
                                                           -4
                                                           -5
                                                           -6
                                                           -7
                                                           -8
                                                           -9
                                                           -10
                                                           2
                                                           3)
                                                          (("2"
                                                            (grind
                                                             :exclude
                                                             "width")
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (hide -4 -5 -6 -7 -8 2 3)
                                  (("2"
                                    (lemma "integral_def")
                                    (("2"
                                      (inst?)
                                      (("2" (assertnil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide -3 -4 -5 -6 -7 2 3)
                                (("2"
                                  (lemma "integral_def")
                                  (("2"
                                    (inst?)
                                    (("2" (assertnil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((T formal-subtype-decl nil integral_step nil)
    (T_pred const-decl "[real -> boolean]" integral_step 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)
    (integrable_lem formula-decl nil integral_prep nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (posreal_div_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (/= const-decl "boolean" notequal nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (step_function_integrable? formula-decl nil integral_step nil)
    (integrable? const-decl "bool" integral_def nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (< const-decl "bool" reals nil)
    (integral? const-decl "bool" integral_def nil)
    (integral const-decl "{S: real | integral?(a, b, ff, S)}"
     integral_def nil)
    (integral_def formula-decl nil integral_def nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (<= const-decl "bool" reals nil)
    (f1!1 skolem-const-decl "[T -> real]" integral_step nil)
    (DD skolem-const-decl "real" integral_step nil)
    (minus_real_is_real application-judgement "real" reals nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (sigma_le formula-decl nil sigma "reals/")
    (integer nonempty-type-from-decl nil integers nil)
    (parts_order formula-decl nil integral_def nil)
    (DD skolem-const-decl "real" integral_step nil)
    (both_sides_times_pos_le1_imp formula-decl nil extra_real_props
     nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (subrange type-eq-decl nil integers 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/")
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (finseq_appl const-decl "[below[length(fs)] -> T]" finite_sequences
     nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (Riemann?_Rie formula-decl nil integral_def nil)
    (xis!1 skolem-const-decl "(xis?(a!1, b!1, P!1))" integral_step nil)
    (f2!1 skolem-const-decl "[T -> real]" integral_step nil)
    (P!1 skolem-const-decl "partition[T](a!1, b!1)" integral_step nil)
    (b!1 skolem-const-decl "T" integral_step nil)
    (a!1 skolem-const-decl "T" integral_step nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (Riemann_sum? const-decl "bool" integral_def 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)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (- const-decl "[T -> real]" real_fun_ops "reals/")
    (integral_diff formula-decl nil integral_prep nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (closed_interval type-eq-decl nil intervals_real "reals/")
    (finite_sequence type-eq-decl nil finite_sequences nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (below type-eq-decl nil naturalnumbers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (partition type-eq-decl nil integral_def nil)
    (xis? const-decl "bool" integral_def nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (width const-decl "posreal" integral_def nil)
    (Rie_sum const-decl "real" integral_def nil))
   nil)
  (step_to_integrable-1 nil 3262523207
   ("" (skosimp*)
    (("" (lemma "integrable_lem")
      (("" (inst?)
        (("" (assert)
          (("" (skosimp*)
            (("" (inst - "epsi!1/3")
              (("" (skosimp*)
                (("" (lemma "step_function_integrable?")
                  (("" (inst-cp -1 "a!1" "b!1" "f2!1")
                    (("" (inst -1 "a!1" "b!1" "f1!1")
                      (("" (assert)
                        (("" (expand "integrable?" -)
                          (("" (skosimp*)
                            ((""
                              (case "integral(a!1, b!1, f1!1) = S!1")
                              (("1"
                                (case "integral(a!1, b!1, f2!1) = S!2")
                                (("1"
                                  (expand "is_integral")
                                  (("1"
                                    (inst -3 "epsi!1/3")
                                    (("1"
                                      (inst -4 "epsi!1/3")
                                      (("1"
                                        (skosimp*)
                                        (("1"
                                          (name
                                           "DEL"
                                           "IF delta!1 <= delta!2 THEN delta!1 ELSE delta!2 ENDIF")
                                          (("1"
                                            (case
                                             "FORALL (P: partition[T](a!1, b!1)):                 width(a!1, b!1, P) < DEL IMPLIES         S!1-epsi!1/3 < Riemann_sum(a!1, b!1, P, f!1) AND         Riemann_sum(a!1, b!1, P, f!1) < S!2+epsi!1/3")
                                            (("1"
                                              (inst + "DEL")
                                              (("1"
                                                (skosimp*)
                                                (("1"
                                                  (inst-cp -1 "P1!1")
                                                  (("1"
                                                    (inst -1 "P2!1")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (lemma
                                                         "integral_diff")
                                                        (("1"
                                                          (inst
                                                           -1
                                                           "a!1"
                                                           "b!1"
                                                           "f2!1"
                                                           "f1!1")
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (flatten)
                                                              (("1"
                                                                (case-replace
                                                                 "(LAMBDA x: f2!1(x) - f1!1(x)) = f2!1 - f1!1")
                                                                (("1"
                                                                  (hide
                                                                   -1)
                                                                  (("1"
                                                                    (replace
                                                                     -2)
                                                                    (("1"
                                                                      (hide
                                                                       -16
                                                                       -17)
                                                                      (("1"
                                                                        (hide
                                                                         -1
                                                                         -2)
                                                                        (("1"
                                                                          (name-replace
                                                                           rsum1
                                                                           "Riemann_sum(a!1, b!1, P1!1, f!1)")
                                                                          (("1"
                                                                            (name-replace
                                                                             rsum2
                                                                             "Riemann_sum(a!1, b!1, P2!1, f!1)")
                                                                            (("1"
                                                                              (replace
                                                                               -6)
                                                                              (("1"
                                                                                (hide
                                                                                 -6)
                                                                                (("1"
                                                                                  (replace
                                                                                   -6)
                                                                                  (("1"
                                                                                    (hide
                                                                                     -6)
                                                                                    (("1"
                                                                                      (hide
                                                                                       -5
                                                                                       -6
                                                                                       -7
                                                                                       -8
                                                                                       -9
                                                                                       -10
                                                                                       -11
                                                                                       2)
                                                                                      (("1"
                                                                                        (grind)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (hide-all-but
                                                                   1)
                                                                  (("2"
                                                                    (expand
                                                                     "-")
                                                                    (("2"
                                                                      (propax)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (hide 2)
                                              (("2"
                                                (skosimp*)
                                                (("2"
                                                  (inst -5 "P!1")
                                                  (("2"
                                                    (inst -6 "P!1")
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (split -5)
                                                        (("1"
                                                          (split -6)
                                                          (("1"
                                                            (hide
                                                             -3
                                                             -4)
                                                            (("1"
                                                              (hide
                                                               -3
                                                               -4
                                                               -5
                                                               -6)
                                                              (("1"
                                                                (case
                                                                 "Riemann_sum(a!1, b!1, P!1, f1!1) <= Riemann_sum(a!1, b!1, P!1, f!1)")
                                                                (("1"
                                                                  (case
                                                                   "Riemann_sum(a!1, b!1, P!1, f!1) <= Riemann_sum(a!1, b!1, P!1, f2!1)")
                                                                  (("1"
                                                                    (hide
                                                                     -5
                                                                     -6)
                                                                    (("1"
                                                                      (hide
                                                                       -5
                                                                       2)
                                                                      (("1"
                                                                        (grind
                                                                         :exclude
                                                                         "Riemann_sum")
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (hide
                                                                     -1
                                                                     -2
                                                                     -3
                                                                     -4
                                                                     -6
                                                                     -7
                                                                     2
                                                                     3)
                                                                    (("2"
                                                                      (expand
                                                                       "Riemann_sum")
                                                                      (("2"
                                                                        (lemma
                                                                         "sigma[upto(length(P!1)-1)].sigma_le")
                                                                        (("1"
                                                                          (inst?)
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (hide
                                                                               2)
                                                                              (("1"
                                                                                (skosimp*)
                                                                                (("1"
                                                                                  (factor
                                                                                   1
                                                                                   l)
                                                                                  (("1"
                                                                                    (factor
                                                                                     1
                                                                                     r)
                                                                                    (("1"
                                                                                      (name
                                                                                       "DD"
                                                                                       "(seq(P!1)(n!1) - seq(P!1)(n!1-1))")
                                                                                      (("1"
                                                                                        (replace
                                                                                         -1)
                                                                                        (("1"
                                                                                          (inst?)
                                                                                          (("1"
                                                                                            (flatten)
                                                                                            (("1"
                                                                                              (mult-by
                                                                                               -3
                                                                                               "DD")
                                                                                              nil
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (hide-all-but
                                                                                             1)
                                                                                            (("2"
                                                                                              (assert)
                                                                                              (("2"
                                                                                                (lemma
                                                                                                 "parts_order")
                                                                                                (("2"
                                                                                                  (inst
                                                                                                   -1
                                                                                                   "a!1"
                                                                                                   "b!1"
                                                                                                   "P!1"
                                                                                                   "0"
                                                                                                   "n!1")
                                                                                                  (("2"
                                                                                                    (assert)
                                                                                                    nil
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil)
                                                                                           ("3"
                                                                                            (hide-all-but
                                                                                             1)
                                                                                            (("3"
                                                                                              (lemma
                                                                                               "parts_order")
                                                                                              (("3"
                                                                                                (inst?)
                                                                                                (("3"
                                                                                                  (assert)
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (hide-all-but
                                                                                       1)
                                                                                      (("2"
                                                                                        (lemma
                                                                                         "parts_order")
                                                                                        (("2"
                                                                                          (inst?)
                                                                                          (("2"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil)
                                                                                   ("2"
                                                                                    (hide-all-but
                                                                                     1)
                                                                                    (("2"
                                                                                      (lemma
                                                                                       "parts_order")
                                                                                      (("2"
                                                                                        (inst?)
                                                                                        (("2"
                                                                                          (assert)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (hide-all-but
                                                                             1)
                                                                            (("2"
                                                                              (skosimp*)
                                                                              (("2"
                                                                                (lemma
                                                                                 "parts_order")
                                                                                (("2"
                                                                                  (inst?)
                                                                                  (("1"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil)
                                                                                   ("2"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("3"
                                                                            (hide-all-but
                                                                             1)
                                                                            (("3"
                                                                              (skosimp*)
                                                                              (("3"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (hide-all-but
                                                                           1)
                                                                          (("2"
                                                                            (skosimp*)
                                                                            (("2"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (hide
                                                                   -1
                                                                   -2
                                                                   -3
                                                                   -5
                                                                   -6
                                                                   2
                                                                   3)
                                                                  (("2"
                                                                    (expand
                                                                     "Riemann_sum")
                                                                    (("2"
                                                                      (lemma
                                                                       "sigma[upto(length(P!1)-1)].sigma_le")
                                                                      (("1"
                                                                        (inst?)
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (hide
                                                                             2)
                                                                            (("1"
                                                                              (skosimp*)
                                                                              (("1"
                                                                                (factor
                                                                                 1
                                                                                 l)
                                                                                (("1"
                                                                                  (factor
                                                                                   1
                                                                                   r)
                                                                                  (("1"
                                                                                    (name
                                                                                     "DD"
                                                                                     "(seq(P!1)(n!1) - seq(P!1)(n!1-1))")
                                                                                    (("1"
                                                                                      (replace
                                                                                       -1)
                                                                                      (("1"
                                                                                        (inst?)
                                                                                        (("1"
                                                                                          (flatten)
                                                                                          (("1"
                                                                                            (mult-by
                                                                                             -2
                                                                                             "DD")
                                                                                            nil
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (hide-all-but
                                                                                           1)
                                                                                          (("2"
                                                                                            (case-replace
                                                                                             "n!1 = 0")
                                                                                            (("1"
                                                                                              (assert)
                                                                                              nil
                                                                                              nil)
                                                                                             ("2"
                                                                                              (lemma
                                                                                               "parts_order")
                                                                                              (("2"
                                                                                                (inst
                                                                                                 -1
                                                                                                 "a!1"
                                                                                                 "b!1"
                                                                                                 "P!1"
                                                                                                 "0"
                                                                                                 "1")
                                                                                                (("2"
                                                                                                  (assert)
                                                                                                  (("2"
                                                                                                    (lemma
                                                                                                     "parts_order")
                                                                                                    (("2"
                                                                                                      (inst
                                                                                                       -1
                                                                                                       "a!1"
                                                                                                       "b!1"
                                                                                                       "P!1"
                                                                                                       "0"
                                                                                                       "n!1")
                                                                                                      (("2"
                                                                                                        (assert)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil)
                                                                                         ("3"
                                                                                          (assert)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil)
                                                                                   ("2"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (hide-all-but
                                                                           1)
                                                                          (("2"
                                                                            (skosimp*)
                                                                            (("2"
                                                                              (assert)
                                                                              (("2"
                                                                                (typepred
                                                                                 "P!1")
                                                                                (("2"
                                                                                  (inst?)
                                                                                  (("2"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("3"
                                                                          (hide-all-but
                                                                           1)
                                                                          (("3"
                                                                            (skosimp*)
                                                                            (("3"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (hide-all-but
                                                                         1)
                                                                        (("2"
                                                                          (skosimp*)
                                                                          (("2"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (hide
                                                             -1
                                                             -4
                                                             -5
                                                             -6
                                                             -7
                                                             -8
                                                             -9
                                                             -10
                                                             2
                                                             3)
                                                            (("2"
                                                              (grind
                                                               :exclude
                                                               "width")
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (hide
                                                           -3
                                                           -4
                                                           -5
                                                           -6
                                                           -7
                                                           -8
                                                           -9
                                                           -10
                                                           2
                                                           3)
                                                          (("2"
                                                            (grind
                                                             :exclude
                                                             "width")
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (hide -4 -5 -6 -7 -8 2 3)
                                  (("2"
                                    (lemma "integral_def")
                                    (("2"
                                      (inst?)
                                      (("2" (assertnil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide -3 -4 -5 -6 -7 2 3)
                                (("2"
                                  (lemma "integral_def")
                                  (("2"
                                    (inst?)
                                    (("2" (assertnil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((integrable_lem formula-decl nil integral_prep nil)
    (integrable? const-decl "bool" integral_def nil)
    (integral const-decl "{S: real | integral?(a, b, ff, S)}"
     integral_def nil)
    (integral_def formula-decl nil integral_def nil)
    (x_in const-decl "{t: T | aa <= t AND t <= bb}" integral_def nil)
    (parts_order formula-decl nil integral_def nil)
    (sigma_le formula-decl nil sigma "reals/")
    (sigma def-decl "real" sigma "reals/")
    (integral_diff formula-decl nil integral_prep nil)
    (partition type-eq-decl nil integral_def nil)
    (width const-decl "posreal" integral_def nil))
   nil)))


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

¤ Dauer der Verarbeitung: 0.344 Sekunden  (vorverarbeitet am  2026-04-27) ¤

*© Formatika GbR, Deutschland






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