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


Quelle  integral_pulse.prf

  Sprache: Lisp
 

(integral_pulse
 (IMP_integral_prep_TCC1 0
  (IMP_integral_prep_TCC1-1 nil 3260699953
   ("" (skosimp*)
    (("" (lemma "connected_domain")
      (("" (inst -1 "x!1" "y!1" "z!1") (("" (assertnil nil)) nil))
      nil))
    nil)
   ((connected_domain formula-decl nil integral_pulse nil)) nil))
 (IMP_integral_prep_TCC2 0
  (IMP_integral_prep_TCC2-1 nil 3260699953
   ("" (lemma "not_one_element") (("" (propax) nil nil)) nil)
   ((not_one_element formula-decl nil integral_pulse nil)) nil))
 (EX3p_TCC1 0
  (EX3p_TCC1-1 nil 3262360238
   ("" (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)
    (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))
 (EX3p_TCC2 0
  (EX3p_TCC2-1 nil 3262360239 ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (T_pred const-decl "[real -> boolean]" integral_pulse nil)
    (T formal-subtype-decl nil integral_pulse 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))
   shostak))
 (EX3p_TCC3 0
  (EX3p_TCC3-1 nil 3262360239 ("" (subtype-tcc) nil nilnil shostak))
 (EX3p_TCC4 0
  (EX3p_TCC4-1 nil 3262360239 ("" (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)
    (T_pred const-decl "[real -> boolean]" integral_pulse nil)
    (T formal-subtype-decl nil integral_pulse nil)
    (upto nonempty-type-eq-decl nil naturalnumbers 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)
    (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 "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))
   shostak))
 (EX3p_TCC5 0
  (EX3p_TCC5-1 nil 3262360240 ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (T_pred const-decl "[real -> boolean]" integral_pulse nil)
    (T formal-subtype-decl nil integral_pulse nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (integer nonempty-type-from-decl nil 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)
    (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 "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))
   shostak))
 (EX3p_TCC6 0
  (EX3p_TCC6-1 nil 3262360240 ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (T_pred const-decl "[real -> boolean]" integral_pulse nil)
    (T formal-subtype-decl nil integral_pulse 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_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)
    (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 "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))
   shostak))
 (EX3p_TCC7 0
  (EX3p_TCC7-1 nil 3352532343 ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (T_pred const-decl "[real -> boolean]" integral_pulse nil)
    (T formal-subtype-decl nil integral_pulse 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_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)
    (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 "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))
   nil))
 (EX3p 0
  (EX3p-1 nil 3262360246
   ("" (skosimp*)
    ((""
      (case "FORALL (P: partition(a!1,b!1),p,q:nat):
                                       0 < p AND p+q <= length(P) - 1 IMPLIES
                                       sigma(p, p+q, (LAMBDA (n: upto(length(P) - 1)):
                                       IF n = 0 THEN 0 ELSE seq(P)(n) - seq(P)(n - 1) ENDIF)) =
                                              seq(P)(p+q) - seq(P)(p-1)")
      (("1" (inst -1 "P!1" "p!1" "q!1-p!1")
        (("1" (assertnil nil) ("2" (assertnil nil)) nil)
       ("2" (hide 2)
        (("2" (induct "q")
          (("1" (skosimp*)
            (("1" (expand "sigma")
              (("1" (ground)
                (("1" (expand "sigma") (("1" (propax) nil nil)) nil))
                nil))
              nil))
            nil)
           ("2" (skosimp*)
            (("2" (inst - "P!2" "p!2")
              (("2" (assert)
                (("2" (expand "sigma" 1)
                  (("2" (replace -1) (("2" (assertnil nil)) nil))
                  nil))
                nil))
              nil))
            nil)
           ("3" (hide 2)
            (("3" (skosimp*) (("3" (assertnil nil)) nil)) nil)
           ("4" (skosimp*) (("4" (assertnil nil)) nil)
           ("5" (skosimp*) (("5" (assertnil nil)) nil)
           ("6" (skosimp*) (("6" (assertnil nil)) nil)
           ("7" (skosimp*) nil nil)
           ("8" (skosimp*) (("8" (assertnil nil)) nil))
          nil))
        nil)
       ("3" (skosimp*) (("3" (assertnil nil)) nil)
       ("4" (skosimp*) (("4" (assertnil nil)) nil)
       ("5" (skosimp*) (("5" (assertnil nil)) nil)
       ("6" (skosimp*) (("6" (assertnil nil)) nil)
       ("7" (skosimp*) nil nil)
       ("8" (hide 2)
        (("8" (skosimp*)
          (("8" (inst + "0") (("8" (assertnil nil)) nil)) nil))
        nil))
      nil))
    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/")
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (OR const-decl "[bool, bool -> bool]" booleans 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 "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)
    (T formal-subtype-decl nil integral_pulse nil)
    (T_pred const-decl "[real -> boolean]" integral_pulse 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)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (integer nonempty-type-from-decl nil integers nil)
    (int_plus_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)
    (p!1 skolem-const-decl "nat" integral_pulse nil)
    (q!1 skolem-const-decl "nat" integral_pulse nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (a!1 skolem-const-decl "T" integral_pulse nil)
    (b!1 skolem-const-decl "T" integral_pulse nil)
    (pred type-eq-decl nil defined_types nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil))
   shostak))
 (EXse_TCC1 0
  (EXse_TCC1-1 nil 3262447218
   ("" (skosimp*) (("" (assertnil nil)) 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))
 (EXse 0
  (EXse-3 nil 3280253181
   ("" (skosimp*)
    (("" (expand "Rie_sec")
      (("" (typepred "P!1")
        (("" (assert)
          (("" (inst - "ii!1-1")
            (("" (name "FF" "f!1(xis!1(ii!1 - 1))")
              (("" (replace -1)
                (("" (lemma "width_lem")
                  (("" (expand "finseq_appl")
                    (("" (inst -1 "a!1" "b!1" "P!1" "ii!1-1")
                      (("" (assert)
                        (("" (case " FF >= 0 AND FF <= 1")
                          (("1" (flatten)
                            (("1" (assert)
                              (("1"
                                (mult-ineq -2 -3)
                                (("1"
                                  (assert)
                                  (("1"
                                    (expand "abs")
                                    (("1"
                                      (move-terms -9 l 1)
                                      (("1"
                                        (assert)
                                        (("1"
                                          (case-replace "FF = 0")
                                          (("1" (assertnil nil)
                                           ("2"
                                            (mult-by -9 "FF")
                                            (("2" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (inst - "xis!1(ii!1-1)")
                            (("2" (ground) nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((real_times_real_is_real application-judgement "real" reals nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (Rie_sec const-decl "real" integral_def nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_abs_is_nonneg application-judgement "{j: nonneg_int | j >= i}"
     real_defs nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (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)
    (xis? const-decl "bool" integral_def nil)
    (width_lem formula-decl nil integral_def nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (IFF const-decl "[bool, bool -> bool]" booleans nil)
    (FF skolem-const-decl "real" integral_pulse nil)
    (both_sides_times_pos_lt1 formula-decl nil real_props nil)
    (le_times_le_any1 formula-decl nil extra_real_props nil)
    (abs_nat formula-decl nil abs_lems "reals/")
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (posreal_times_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (width const-decl "posreal" integral_def nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (finseq_appl const-decl "[below[length(fs)] -> T]" finite_sequences
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (> const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (T_pred const-decl "[real -> boolean]" integral_pulse nil)
    (T formal-subtype-decl nil integral_pulse 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)
    (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))
   nil)
  (EXse-2 nil 3262529290
   ("" (skosimp*)
    (("" (expand "Rie_sec")
      (("" (typepred "P!1")
        (("" (assert)
          (("" (inst - "ii!1-1")
            (("" (name "FF" "f!1(xis!1`seq(ii!1 - 1))")
              (("1" (replace -1)
                (("1" (lemma "width_lem")
                  (("1" (expand "finseq_appl")
                    (("1" (inst -1 "a!1" "b!1" "P!1" "ii!1-1")
                      (("1" (assert)
                        (("1" (case " FF >= 0 AND FF <= 1")
                          (("1" (flatten)
                            (("1" (assert)
                              (("1"
                                (mult-ineq -2 -3)
                                (("1"
                                  (assert)
                                  (("1"
                                    (expand "abs")
                                    (("1"
                                      (move-terms -9 l 1)
                                      (("1"
                                        (assert)
                                        (("1"
                                          (case-replace "FF = 0")
                                          (("1" (assertnil nil)
                                           ("2"
                                            (mult-by -9 "FF")
                                            (("2" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (inst - "xis!1`seq(ii!1-1)")
                            (("1" (ground) nil nil)
                             ("2" (assert)
                              (("2"
                                (typepred "xis!1")
                                (("2" (assertnil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (typepred "xis!1")
                (("2" (assert)
                  (("2" (flatten) (("2" (assertnil nil)) nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((Rie_sec const-decl "real" integral_def nil)
    (xis? const-decl "bool" integral_def nil)
    (width_lem formula-decl nil integral_def nil)
    (width const-decl "posreal" integral_def nil)
    (partition type-eq-decl nil integral_def nil))
   nil)
  (EXse-1 nil 3262440806
   ("" (skosimp*)
    (("" (expand "section")
      (("" (typepred "P!1")
        (("" (inst - "ii!1-1")
          (("1"
            (name "FF" "f!1(x_in(seq(P!1)(ii!1 - 1), seq(P!1)(ii!1)))")
            (("1" (replace -1)
              (("1" (lemma "width_lem")
                (("1" (expand "finseq_appl")
                  (("1" (inst -1 "a!1" "b!1" "P!1" "ii!1-1")
                    (("1" (assert)
                      (("1" (case " FF >= 0 AND FF <= 1")
                        (("1" (flatten)
                          (("1" (assert)
                            (("1" (mult-ineq -2 -3)
                              (("1"
                                (assert)
                                (("1"
                                  (expand "abs")
                                  (("1"
                                    (move-terms -9 l 1)
                                    (("1"
                                      (assert)
                                      (("1"
                                        (case-replace "FF = 0")
                                        (("1" (assertnil nil)
                                         ("2"
                                          (mult-by -9 "FF")
                                          (("2" (assertnil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2"
                          (inst -
                           "x_in(seq(P!1)(ii!1-1), seq(P!1)(ii!1))")
                          (("2" (ground) nil nil)) nil))
                        nil))
                      nil)
                     ("2" (assertnil nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (assertnil nil) ("3" (propax) nil nil)
             ("4" (assertnil nil))
            nil)
           ("2" (assertnil nil))
          nil))
        nil))
      nil))
    nil)
   ((width const-decl "posreal" integral_def nil)
    (width_lem formula-decl nil integral_def nil)
    (x_in const-decl "{t: T | aa <= t AND t <= bb}" integral_def nil)
    (partition type-eq-decl nil integral_def nil))
   shostak))
 (Example_3_TCC1 0
  (Example_3_TCC1-1 nil 3262529445
   ("" (skosimp*) (("" (assertnil nil)) nil)
   ((real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   shostak))
 (Example_3 0
  (Example_3-5 nil 3282559921
   ("" (auto-rewrite "xis?")
    (("" (auto-rewrite "xis_lem")
      (("" (skosimp*)
        (("" (rewrite "integral_def")
          (("" (expand "integral?")
            (("" (skosimp*)
              (("" (inst + "epsi!1/1000")
                (("" (skosimp*)
                  (("" (typepred "R!1")
                    (("" (expand "Riemann_sum?")
                      (("" (skosimp*)
                        (("" (replace -1)
                          (("" (hide -1)
                            (("" (lemma "Rie_sum_alt_lem")
                              ((""
                                (inst - "a!1" "b!1" "f!1")
                                ((""
                                  (assert)
                                  ((""
                                    (inst?)
                                    ((""
                                      (replace -1)
                                      ((""
                                        (hide -1)
                                        ((""
                                          (name "N" "length(P!1)")
                                          ((""
                                            (case
                                             "(EXISTS (k: below(N-1)): xl!1 < seq(P!1)(k) AND seq(P!1)(k+1) < xh!1)")
                                            (("1"
                                              (skosimp*)
                                              (("1"
                                                (case
                                                 "EXISTS (p,q: nat): p >= 1 AND p <= length(P!1) -1
                                                                                                                                                                                                      AND seq(P!1)(p-1) <= xl!1 AND xl!1 < seq(P!1)(p)
                                                                                                                                                                                                      AND    q >=  1 AND q <= length(P!1) - 1
                                                                                                                                                                                                      AND seq(P!1)(q-1) < xh!1 AND xh!1 <= seq(P!1)(q) AND p+1 <= q-1")
                                                (("1"
                                                  (skosimp*)
                                                  (("1"
                                                    (expand
                                                     "Rie_sum_alt")
                                                    (("1"
                                                      (expand
                                                       "Rie_sec")
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (name
                                                           "SEC"
                                                           "       LAMBDA (n: upto(length(P!1) - 1)):
                                                                                                                                                                                                                                                                                                                                                                                                                   IF n = 0 THEN 0
                                                                                                                                                                                                                                                                                                                                                                                                                   ELSE seq(P!1)(n) *
                                                                                                                                                                                                                                                                                                                                                                       f!1(xis!1(n - 1))
                                                                                                                                                                                                                                                                                                                                                                                                                         -
                                                                                                                                                                                                                                                                                                                                                                                                                         seq(P!1)(n - 1) *
                                                                                                                                                                                                                                                                                                                                                                                                                          f!1(xis!1(n - 1))
                                                                                                                                                                                                                                                                                                                                                                                                                   ENDIF")
                                                          (("1"
                                                            (replace
                                                             -1)
                                                            (("1"
                                                              (name
                                                               "SS"
                                                               "sigma[upto(length(P!1) - 1)](1, length(P!1) - 1, SEC)")
                                                              (("1"
                                                                (replace
                                                                 -1)
                                                                (("1"
                                                                  (case
                                                                   "sigma(p!1+1,q!1-1,SEC) <= SS AND SS <= sigma(p!1,q!1,SEC)")
                                                                  (("1"
                                                                    (flatten)
                                                                    (("1"
                                                                      (case
                                                                       "sigma(p!1+1, q!1 - 1, SEC) = seq(P!1)(q!1-1) - seq(P!1)(p!1)")
                                                                      (("1"
                                                                        (case
                                                                         "sigma(p!1, q!1, SEC) <= seq(P!1)(q!1) - seq(P!1)(p!1-1)")
                                                                        (("1"
                                                                          (case-replace
                                                                           "abs(-1 * SS - xl!1 + xh!1) = abs(SS - xh!1 + xl!1)")
                                                                          (("1"
                                                                            (hide
                                                                             -1)
                                                                            (("1"
                                                                              (expand
                                                                               "abs")
                                                                              (("1"
                                                                                (lift-if)
                                                                                (("1"
                                                                                  (hide
                                                                                   -6
                                                                                   -22)
                                                                                  (("1"
                                                                                    (lemma
                                                                                     "width_lem")
                                                                                    (("1"
                                                                                      (expand
                                                                                       "finseq_appl")
                                                                                      (("1"
                                                                                        (inst-cp
                                                                                         -
                                                                                         "a!1"
                                                                                         "b!1"
                                                                                         "P!1"
                                                                                         "p!1-1")
                                                                                        (("1"
                                                                                          (inst-cp
                                                                                           -
                                                                                           "a!1"
                                                                                           "b!1"
                                                                                           "P!1"
                                                                                           "p!1")
                                                                                          (("1"
                                                                                            (inst
                                                                                             -
                                                                                             "a!1"
                                                                                             "b!1"
                                                                                             "P!1"
                                                                                             "q!1-1")
                                                                                            (("1"
                                                                                              (ground)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (hide-all-but
                                                                             1)
                                                                            (("2"
                                                                              (lemma
                                                                               "abs_neg")
                                                                              (("2"
                                                                                (inst
                                                                                 -
                                                                                 "SS - xh!1 + xl!1")
                                                                                (("2"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (lemma
                                                                           "EX3p")
                                                                          (("2"
                                                                            (inst
                                                                             -1
                                                                             "a!1"
                                                                             "b!1")
                                                                            (("2"
                                                                              (inst?)
                                                                              (("2"
                                                                                (assert)
                                                                                (("2"
                                                                                  (inst
                                                                                   -1
                                                                                   "P!1"
                                                                                   "p!1"
                                                                                   "q!1")
                                                                                  (("2"
                                                                                    (assert)
                                                                                    (("2"
                                                                                      (assert)
                                                                                      (("2"
                                                                                        (replace
                                                                                         -1
                                                                                         +
                                                                                         rl)
                                                                                        (("2"
                                                                                          (rewrite
                                                                                           "sigma_le")
                                                                                          (("1"
                                                                                            (hide
                                                                                             2)
                                                                                            (("1"
                                                                                              (skosimp*)
                                                                                              (("1"
                                                                                                (replace
                                                                                                 -6
                                                                                                 +
                                                                                                 rl)
                                                                                                (("1"
                                                                                                  (assert)
                                                                                                  (("1"
                                                                                                    (hide
                                                                                                     -1
                                                                                                     -2
                                                                                                     -3
                                                                                                     -4
                                                                                                     -5
                                                                                                     -6)
                                                                                                    (("1"
                                                                                                      (case
                                                                                                       "f!1(xis!1(n!1 - 1)) <= 1")
                                                                                                      (("1"
                                                                                                        (assert)
                                                                                                        (("1"
                                                                                                          (mult-by
                                                                                                           -1
                                                                                                           "seq(P!1)(n!1) - seq(P!1)(n!1 - 1)")
                                                                                                          (("1"
                                                                                                            (assert)
                                                                                                            nil
                                                                                                            nil)
                                                                                                           ("2"
                                                                                                            (hide
                                                                                                             2)
                                                                                                            (("2"
                                                                                                              (typepred
                                                                                                               "xis!1")
                                                                                                              (("2"
                                                                                                                (assert)
                                                                                                                (("2"
                                                                                                                  (inst
                                                                                                                   -
                                                                                                                   "n!1-1")
                                                                                                                  (("2"
                                                                                                                    (assert)
                                                                                                                    (("2"
                                                                                                                      (flatten)
                                                                                                                      (("2"
                                                                                                                        (assert)
                                                                                                                        nil
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil)
                                                                                                       ("2"
                                                                                                        (hide
                                                                                                         2)
                                                                                                        (("2"
                                                                                                          (reveal
                                                                                                           -8)
                                                                                                          (("2"
                                                                                                            (inst
                                                                                                             -
                                                                                                             "xis!1(n!1 - 1)")
                                                                                                            (("2"
                                                                                                              (assert)
                                                                                                              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))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (lemma
                                                                         "EX3p")
                                                                        (("2"
                                                                          (inst
                                                                           -1
                                                                           "a!1"
                                                                           "b!1")
                                                                          (("2"
                                                                            (assert)
                                                                            (("2"
                                                                              (inst
                                                                               -1
                                                                               "P!1"
                                                                               "p!1+1"
                                                                               "q!1-1")
                                                                              (("2"
                                                                                (assert)
                                                                                (("2"
                                                                                  (case
                                                                                   "1 + p!1 <= q!1 - 1")
                                                                                  (("1"
                                                                                    (assert)
                                                                                    (("1"
                                                                                      (hide
                                                                                       2)
                                                                                      (("1"
                                                                                        (replace
                                                                                         -2
                                                                                         +
                                                                                         rl)
                                                                                        (("1"
                                                                                          (hide
                                                                                           -2)
                                                                                          (("1"
                                                                                            (rewrite
                                                                                             "sigma_restrict_eq")
                                                                                            (("1"
                                                                                              (hide
                                                                                               2)
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "restrict")
                                                                                                (("1"
                                                                                                  (apply-extensionality
                                                                                                   1
                                                                                                   :hide?
                                                                                                   t)
                                                                                                  (("1"
                                                                                                    (lift-if)
                                                                                                    (("1"
                                                                                                      (ground)
                                                                                                      (("1"
                                                                                                        (replace
                                                                                                         -5
                                                                                                         +
                                                                                                         rl)
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          (("1"
                                                                                                            (inst
                                                                                                             -
                                                                                                             "xis!1(x!1 - 1)")
                                                                                                            (("1"
                                                                                                              (hide
                                                                                                               -2
                                                                                                               -3
                                                                                                               -4
                                                                                                               -5)
                                                                                                              (("1"
                                                                                                                (lemma
                                                                                                                 "parts_order")
                                                                                                                (("1"
                                                                                                                  (inst-cp
                                                                                                                   -1
                                                                                                                   "a!1"
                                                                                                                   "b!1"
                                                                                                                   "P!1"
                                                                                                                   "p!1"
                                                                                                                   "x!1-1")
                                                                                                                  (("1"
                                                                                                                    (inst-cp
                                                                                                                     -1
                                                                                                                     "a!1"
                                                                                                                     "b!1"
                                                                                                                     "P!1"
                                                                                                                     "x!1"
                                                                                                                     "q!1-1")
                                                                                                                    (("1"
                                                                                                                      (hide
                                                                                                                       -1)
                                                                                                                      (("1"
                                                                                                                        (typepred
                                                                                                                         "xis!1")
                                                                                                                        (("1"
                                                                                                                          (expand
                                                                                                                           "xis?")
                                                                                                                          (("1"
                                                                                                                            (assert)
                                                                                                                            (("1"
                                                                                                                              (lemma
                                                                                                                               "xis_lem")
                                                                                                                              (("1"
                                                                                                                                (assert)
                                                                                                                                (("1"
                                                                                                                                  (inst?)
                                                                                                                                  (("1"
                                                                                                                                    (flatten)
                                                                                                                                    (("1"
                                                                                                                                      (ground)
                                                                                                                                      nil
                                                                                                                                      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)
                                                                                                   ("3"
                                                                                                    (skosimp*)
                                                                                                    (("3"
                                                                                                      (assert)
                                                                                                      (("3"
                                                                                                        (expand
                                                                                                         "SEC")
                                                                                                        (("3"
                                                                                                          (propax)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil)
                                                                                             ("2"
                                                                                              (skosimp*)
                                                                                              (("2"
                                                                                                (assert)
                                                                                                nil
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil)
                                                                                   ("2"
                                                                                    (propax)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (assert)
                                                                      (("2"
                                                                        (hide
                                                                         2)
                                                                        (("2"
                                                                          (replace
                                                                           -14)
                                                                          (("2"
                                                                            (prop)
                                                                            (("1"
                                                                              (lemma
                                                                               "sigma_upto[length(P!1) - 1].sigma_split_ge")
                                                                              (("1"
                                                                                (inst
                                                                                 -1
                                                                                 "_"
                                                                                 "N-1"
                                                                                 "1"
                                                                                 "p!1")
                                                                                (("1"
                                                                                  (inst?)
                                                                                  (("1"
                                                                                    (assert)
                                                                                    (("1"
                                                                                      (replace
                                                                                       -1)
                                                                                      (("1"
                                                                                        (hide
                                                                                         -1)
                                                                                        (("1"
                                                                                          (lemma
                                                                                           "sigma_upto[length(P!1) - 1].sigma_split_ge")
                                                                                          (("1"
                                                                                            (inst
                                                                                             -1
                                                                                             "_"
                                                                                             "N-1"
                                                                                             "1+p!1"
                                                                                             "q!1-1")
                                                                                            (("1"
                                                                                              (inst?)
                                                                                              (("1"
                                                                                                (assert)
                                                                                                (("1"
                                                                                                  (replace
                                                                                                   -1)
                                                                                                  (("1"
                                                                                                    (case-replace
                                                                                                     "sigma(q!1, N - 1, SEC) >= 0 AND sigma(1, p!1, SEC) >= 0")
                                                                                                    (("1"
                                                                                                      (flatten)
                                                                                                      (("1"
                                                                                                        (assert)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (hide
                                                                                                       2)
                                                                                                      (("2"
                                                                                                        (lemma
                                                                                                         "sigma_nonneg[upto(length(P!1)-1)]")
                                                                                                        (("2"
                                                                                                          (case
                                                                                                           "(FORALL (i: upto(length(P!1) - 1)): SEC(i) >= 0)")
                                                                                                          (("1"
                                                                                                            (inst-cp
                                                                                                             -2
                                                                                                             "SEC"
                                                                                                             "N-1"
                                                                                                             "q!1")
                                                                                                            (("1"
                                                                                                              (inst
                                                                                                               -2
                                                                                                               "SEC"
                                                                                                               "p!1"
                                                                                                               "1")
                                                                                                              (("1"
                                                                                                                (assert)
                                                                                                                (("1"
                                                                                                                  (replace
                                                                                                                   -1)
                                                                                                                  (("1"
                                                                                                                    (assert)
                                                                                                                    nil
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil)
                                                                                                           ("2"
                                                                                                            (skosimp*)
                                                                                                            (("2"
                                                                                                              (hide
                                                                                                               2)
                                                                                                              (("2"
                                                                                                                (replace
                                                                                                                 -4
                                                                                                                 +
                                                                                                                 rl)
                                                                                                                (("2"
                                                                                                                  (assert)
                                                                                                                  (("2"
                                                                                                                    (hide
                                                                                                                     -1
                                                                                                                     -2
                                                                                                                     -3
                                                                                                                     -4)
                                                                                                                    (("2"
                                                                                                                      (lift-if)
                                                                                                                      (("2"
                                                                                                                        (ground)
                                                                                                                        (("2"
                                                                                                                          (inst
                                                                                                                           -
                                                                                                                           "xis!1(i!1 - 1)")
                                                                                                                          (("2"
                                                                                                                            (lemma
                                                                                                                             "xis_lem")
                                                                                                                            (("2"
                                                                                                                              (assert)
                                                                                                                              (("2"
                                                                                                                                (inst?)
                                                                                                                                (("2"
                                                                                                                                  (flatten)
                                                                                                                                  (("2"
                                                                                                                                    (ground)
                                                                                                                                    nil
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil)
                                                                                                           ("3"
                                                                                                            (skosimp*)
                                                                                                            (("3"
                                                                                                              (expand
                                                                                                               "SEC")
                                                                                                              (("3"
                                                                                                                (propax)
                                                                                                                nil
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("3"
                                                                                                      (flatten)
                                                                                                      (("3"
                                                                                                        (skosimp*)
                                                                                                        (("3"
                                                                                                          (assert)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (assert)
                                                                              (("2"
                                                                                (lemma
                                                                                 "sigma_upto[length(P!1) - 1].sigma_split_ge")
                                                                                (("2"
                                                                                  (inst
                                                                                   -1
                                                                                   "_"
                                                                                   "N-1"
                                                                                   "1"
                                                                                   "p!1-1")
                                                                                  (("2"
                                                                                    (inst?)
                                                                                    (("2"
                                                                                      (assert)
                                                                                      (("2"
                                                                                        (replace
                                                                                         -1)
                                                                                        (("2"
                                                                                          (hide
                                                                                           -1)
                                                                                          (("2"
                                                                                            (case-replace
                                                                                             "sigma(1, p!1 - 1, SEC) = 0")
                                                                                            (("1"
                                                                                              (assert)
                                                                                              (("1"
                                                                                                (hide
                                                                                                 -1)
                                                                                                (("1"
                                                                                                  (lemma
                                                                                                   "sigma_upto[length(P!1) - 1].sigma_split_ge")
                                                                                                  (("1"
                                                                                                    (inst
                                                                                                     -1
                                                                                                     "_"
                                                                                                     "N-1"
                                                                                                     "p!1"
                                                                                                     "q!1")
                                                                                                    (("1"
                                                                                                      (inst?)
                                                                                                      (("1"
                                                                                                        (assert)
                                                                                                        (("1"
                                                                                                          (replace
                                                                                                           -1)
                                                                                                          (("1"
                                                                                                            (hide
                                                                                                             -1)
                                                                                                            (("1"
                                                                                                              (case-replace
                                                                                                               "sigma(1 + q!1, N - 1, SEC) = 0")
                                                                                                              (("1"
                                                                                                                (assert)
                                                                                                                nil
                                                                                                                nil)
                                                                                                               ("2"
                                                                                                                (hide
                                                                                                                 -1)
                                                                                                                (("2"
                                                                                                                  (hide
                                                                                                                   2)
                                                                                                                  (("2"
                                                                                                                    (case-replace
                                                                                                                     "sigma(1+q!1,N-1, SEC) = sigma(1+q!1,N-1,(LAMBDA (n: upto(length(P!1) - 1)): 0))")
                                                                                                                    (("1"
                                                                                                                      (rewrite
                                                                                                                       "sigma_const[upto(length(P!1) - 1)]")
                                                                                                                      nil
                                                                                                                      nil)
                                                                                                                     ("2"
                                                                                                                      (hide
                                                                                                                       2)
                                                                                                                      (("2"
                                                                                                                        (rewrite
                                                                                                                         "sigma_restrict_eq")
                                                                                                                        (("2"
                                                                                                                          (hide
                                                                                                                           2)
                                                                                                                          (("2"
                                                                                                                            (expand
                                                                                                                             "restrict")
                                                                                                                            (("2"
                                                                                                                              (apply-extensionality
                                                                                                                               1
                                                                                                                               :hide?
                                                                                                                               t)
                                                                                                                              (("1"
                                                                                                                                (lift-if)
                                                                                                                                (("1"
                                                                                                                                  (ground)
                                                                                                                                  (("1"
                                                                                                                                    (replace
                                                                                                                                     -1
                                                                                                                                     +
                                                                                                                                     rl)
                                                                                                                                    (("1"
                                                                                                                                      (assert)
                                                                                                                                      (("1"
                                                                                                                                        (inst
                                                                                                                                         -
                                                                                                                                         "xis!1(x!1 - 1)")
                                                                                                                                        (("1"
                                                                                                                                          (case
                                                                                                                                           "xis!1(x!1 - 1) >= xh!1")
                                                                                                                                          (("1"
                                                                                                                                            (assert)
                                                                                                                                            nil
                                                                                                                                            nil)
                                                                                                                                           ("2"
                                                                                                                                            (assert)
                                                                                                                                            (("2"
                                                                                                                                              (typepred
                                                                                                                                               "xis!1")
                                                                                                                                              (("2"
                                                                                                                                                (assert)
                                                                                                                                                (("2"
                                                                                                                                                  (lemma
                                                                                                                                                   "parts_order")
                                                                                                                                                  (("2"
                                                                                                                                                    (inst-cp
                                                                                                                                                     -1
                                                                                                                                                     "a!1"
                                                                                                                                                     "b!1"
                                                                                                                                                     "P!1"
                                                                                                                                                     "q!1-1"
                                                                                                                                                     "x!1")
                                                                                                                                                    (("2"
                                                                                                                                                      (inst-cp
                                                                                                                                                       -1
                                                                                                                                                       "a!1"
                                                                                                                                                       "b!1"
                                                                                                                                                       "P!1"
                                                                                                                                                       "q!1"
                                                                                                                                                       "x!1")
                                                                                                                                                      (("2"
                                                                                                                                                        (inst-cp
                                                                                                                                                         -1
                                                                                                                                                         "a!1"
                                                                                                                                                         "b!1"
                                                                                                                                                         "P!1"
                                                                                                                                                         "q!1+1"
                                                                                                                                                         "x!1")
                                                                                                                                                        (("2"
                                                                                                                                                          (assert)
                                                                                                                                                          (("2"
                                                                                                                                                            (inst
                                                                                                                                                             -1
                                                                                                                                                             "a!1"
                                                                                                                                                             "b!1"
                                                                                                                                                             "P!1"
                                                                                                                                                             "q!1"
                                                                                                                                                             "x!1-1")
                                                                                                                                                            (("2"
                                                                                                                                                              (lemma
                                                                                                                                                               "xis_lem")
                                                                                                                                                              (("2"
                                                                                                                                                                (inst
                                                                                                                                                                 -1
                                                                                                                                                                 "a!1"
                                                                                                                                                                 "b!1"
                                                                                                                                                                 "P!1"
                                                                                                                                                                 "xis!1"
                                                                                                                                                                 "x!1-1")
                                                                                                                                                                (("2"
                                                                                                                                                                  (assert)
                                                                                                                                                                  nil
                                                                                                                                                                  nil))
                                                                                                                                                                nil))
                                                                                                                                                              nil))
                                                                                                                                                            nil))
                                                                                                                                                          nil))
                                                                                                                                                        nil))
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil)
                                                                                                                               ("2"
                                                                                                                                (skosimp*)
                                                                                                                                (("2"
                                                                                                                                  (expand
                                                                                                                                   "SEC")
                                                                                                                                  (("2"
                                                                                                                                    (propax)
                                                                                                                                    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(1, p!1 - 1, SEC) = sigma(1,p!1-1,(LAMBDA (n: upto(length(P!1) - 1)): 0))")
                                                                                              (("1"
                                                                                                (hide
                                                                                                 -1
                                                                                                 -2
                                                                                                 -3)
                                                                                                (("1"
                                                                                                  (rewrite
                                                                                                   "sigma_const[upto(length(P!1) - 1)]")
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil)
                                                                                               ("2"
                                                                                                (rewrite
                                                                                                 "sigma_restrict_eq")
                                                                                                (("2"
                                                                                                  (expand
                                                                                                   "restrict")
                                                                                                  (("2"
                                                                                                    (apply-extensionality
                                                                                                     1
                                                                                                     :hide?
                                                                                                     t)
                                                                                                    (("1"
                                                                                                      (lift-if)
                                                                                                      (("1"
                                                                                                        (ground)
                                                                                                        (("1"
                                                                                                          (hide
                                                                                                           4
                                                                                                           5
                                                                                                           6)
                                                                                                          (("1"
                                                                                                            (replace
                                                                                                             -2
                                                                                                             +
                                                                                                             rl)
                                                                                                            (("1"
                                                                                                              (assert)
                                                                                                              (("1"
                                                                                                                (inst
                                                                                                                 -
                                                                                                                 "xis!1(x!1-1)")
                                                                                                                (("1"
                                                                                                                  (case
                                                                                                                   "xl!1 >= xis!1(x!1-1)")
                                                                                                                  (("1"
                                                                                                                    (ground)
                                                                                                                    nil
                                                                                                                    nil)
                                                                                                                   ("2"
                                                                                                                    (typepred
                                                                                                                     "xis!1")
                                                                                                                    (("2"
                                                                                                                      (assert)
                                                                                                                      (("2"
                                                                                                                        (hide
                                                                                                                         4)
                                                                                                                        (("2"
                                                                                                                          (lemma
                                                                                                                           "parts_order")
                                                                                                                          (("2"
                                                                                                                            (inst-cp
                                                                                                                             -1
                                                                                                                             "a!1"
                                                                                                                             "b!1"
                                                                                                                             "P!1"
                                                                                                                             "x!1"
                                                                                                                             "p!1-1")
                                                                                                                            (("2"
                                                                                                                              (assert)
                                                                                                                              (("2"
                                                                                                                                (lemma
                                                                                                                                 "xis_lem")
                                                                                                                                (("2"
                                                                                                                                  (inst
                                                                                                                                   -1
                                                                                                                                   "a!1"
                                                                                                                                   "b!1"
                                                                                                                                   "P!1"
                                                                                                                                   "xis!1"
                                                                                                                                   "x!1-1")
                                                                                                                                  (("2"
                                                                                                                                    (assert)
                                                                                                                                    (("2"
                                                                                                                                      (flatten)
                                                                                                                                      (("2"
                                                                                                                                        (assert)
                                                                                                                                        nil
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (skosimp*)
                                                                                                      (("2"
                                                                                                        (expand
                                                                                                         "SEC")
                                                                                                        (("2"
                                                                                                          (propax)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("3"
                                                                    (flatten)
                                                                    (("3"
                                                                      (skosimp*)
                                                                      (("3"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (skosimp*)
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (skosimp*)
                                                            (("2"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil)
                                                           ("3"
                                                            (skosimp*)
                                                            (("3"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (name
                                                   "M_xl"
                                                   "min_nat.min({j: below(N) | seq(P!1)(j) > xl!1})")
                                                  (("1"
                                                    (name
                                                     "M_xh"
                                                     "min_nat.min({j: below(N) | seq(P!1)(j) >= xh!1})")
                                                    (("1"
                                                      (inst
                                                       +
                                                       "M_xl"
                                                       "M_xh")
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (typepred
                                                           "M_xh")
                                                          (("1"
                                                            (inst
                                                             -
                                                             "M_xh-1")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (typepred
                                                                 "M_xl")
                                                                (("1"
                                                                  (typepred
                                                                   "M_xl")
                                                                  (("1"
                                                                    (inst
                                                                     -
                                                                     "M_xl-1")
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (inst
                                                                         -5
                                                                         "k!1")
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (typepred
                                                                             "M_xh")
                                                                            (("1"
                                                                              (inst
                                                                               -3
                                                                               "k!1+1")
                                                                              (("1"
                                                                                (lemma
                                                                                 "parts_order")
                                                                                (("1"
                                                                                  (inst-cp
                                                                                   -1
                                                                                   "a!1"
                                                                                   "b!1"
                                                                                   "P!1"
                                                                                   "M_xl"
                                                                                   "k!1+1")
                                                                                  (("1"
                                                                                    (assert)
                                                                                    (("1"
                                                                                      (inst-cp
                                                                                       -1
                                                                                       "a!1"
                                                                                       "b!1"
                                                                                       "P!1"
                                                                                       "M_xh"
                                                                                       "k!1")
                                                                                      (("1"
                                                                                        (inst-cp
                                                                                         -1
                                                                                         "a!1"
                                                                                         "b!1"
                                                                                         "P!1"
                                                                                         "M_xh"
                                                                                         "k!1+1")
                                                                                        (("1"
                                                                                          (assert)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (expand
                                                       "nonempty?")
                                                      (("2"
                                                        (expand
                                                         "empty?")
                                                        (("2"
                                                          (expand
                                                           "member")
                                                          (("2"
                                                            (inst
                                                             -1
                                                             "N-1")
                                                            (("2"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (expand
                                                     "nonempty?")
                                                    (("2"
                                                      (expand "empty?")
                                                      (("2"
                                                        (expand
                                                         "member")
                                                        (("2"
                                                          (inst
                                                           -1
                                                           "k!1")
                                                          (("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("3"
                                                    (skosimp*)
                                                    (("3"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("3"
                                                  (skosimp*)
                                                  (("3"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil)
                                                 ("4"
                                                  (skosimp*)
                                                  (("4"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil)
                                                 ("5"
                                                  (skosimp*)
                                                  (("5"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil)
                                                 ("6"
                                                  (skosimp*)
                                                  (("6"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (lemma "triangle")
                                              (("2"
                                                (inst
                                                 -1
                                                 "-1 * Rie_sum(a!1, b!1, P!1, xis!1, f!1)"
                                                 "xh!1-xl!1")
                                                (("2"
                                                  (case
                                                   "abs(xh!1 - xl!1) < epsi!1/2")
                                                  (("1"
                                                    (case
                                                     "abs(-1 * Rie_sum(a!1, b!1, P!1, xis!1, f!1)) < epsi!1/2")
                                                    (("1"
                                                      (assert)
                                                      nil
                                                      nil)
                                                     ("2"
                                                      (hide 3)
                                                      (("2"
                                                        (rewrite
                                                         "abs_mult")
                                                        (("2"
                                                          (case-replace
                                                           "abs(-1) = 1")
                                                          (("1"
                                                            (hide
                                                             -1
                                                             -2
                                                             -3)
                                                            (("1"
                                                              (lemma
                                                               "Rie_sum_alt_lem")
                                                              (("1"
                                                                (inst
                                                                 -
                                                                 "a!1"
                                                                 "b!1"
                                                                 "f!1")
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (inst?)
                                                                    (("1"
                                                                      (replace
                                                                       -1)
                                                                      (("1"
                                                                        (hide
                                                                         -1)
                                                                        (("1"
                                                                          (expand
                                                                           "Rie_sum_alt")
                                                                          (("1"
                                                                            (name
                                                                             "M_xh"
                                                                             "min_nat.min({j: below(N) | seq(P!1)(j) >= xh!1})")
                                                                            (("1"
                                                                              (case
                                                                               "M_xh > 1")
                                                                              (("1"
                                                                                (inst
                                                                                 +
                                                                                 "M_xh-2")
                                                                                (("1"
                                                                                  (assert)
                                                                                  (("1"
                                                                                    (typepred
                                                                                     "M_xh")
                                                                                    (("1"
                                                                                      (inst
                                                                                       -
                                                                                       "M_xh-1")
                                                                                      (("1"
                                                                                        (assert)
                                                                                        (("1"
                                                                                          (lemma
                                                                                           "sigma_upto[length(P!1) - 1].sigma_split_ge")
                                                                                          (("1"
                                                                                            (inst
                                                                                             -1
                                                                                             "_"
                                                                                             "N-1"
                                                                                             "1"
                                                                                             "M_xh-2")
                                                                                            (("1"
                                                                                              (inst
                                                                                               -
                                                                                               "(LAMBDA (n: upto(length(P!1) - 1)):
                                                                                                                                                                                                                                                                                                                                                                                            Rie_sec(a!1, b!1, P!1, xis!1, f!1, n))")
                                                                                              (("1"
                                                                                                (assert)
                                                                                                (("1"
                                                                                                  (replace
                                                                                                   -6)
                                                                                                  (("1"
                                                                                                    (replace
                                                                                                     -1)
                                                                                                    (("1"
                                                                                                      (hide
                                                                                                       -1)
                                                                                                      (("1"
                                                                                                        (assert)
                                                                                                        (("1"
                                                                                                          (case-replace
                                                                                                           "sigma(1, M_xh - 2,
                                                                                                                                                                                                                                                                                                                                                                                           (LAMBDA (n: upto(length(P!1) - 1)):
                                                                                                                                                                                                                                                                                                                                                                                              Rie_sec(a!1, b!1, P!1, xis!1, f!1, n))) = 0")
                                                                                                          (("1"
                                                                                                            (assert)
                                                                                                            (("1"
                                                                                                              (case
                                                                                                               "abs(Rie_sec(a!1, b!1, P!1, xis!1, f!1, M_xh)) < epsi!1 / 4")
                                                                                                              (("1"
                                                                                                                (case
                                                                                                                 "abs(Rie_sec(a!1, b!1, P!1, xis!1, f!1, M_xh-1)) < epsi!1 / 4")
                                                                                                                (("1"
                                                                                                                  (lemma
                                                                                                                   "sigma_upto[length(P!1) - 1].sigma_first_ge")
                                                                                                                  (("1"
                                                                                                                    (inst
                                                                                                                     -
                                                                                                                     "(LAMBDA (n: upto(length(P!1) - 1)):
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Rie_sec(a!1, b!1, P!1, xis!1, f!1, n))"
                                                                                                                     "N-1"
                                                                                                                     "M_xh-1")
                                                                                                                    (("1"
                                                                                                                      (assert)
                                                                                                                      (("1"
                                                                                                                        (replace
                                                                                                                         -1)
                                                                                                                        (("1"
                                                                                                                          (hide
                                                                                                                           -1)
                                                                                                                          (("1"
                                                                                                                            (case
                                                                                                                             "1 + M_xh <= length(P!1) - 1")
                                                                                                                            (("1"
                                                                                                                              (lemma
                                                                                                                               "sigma_upto[length(P!1) - 1].sigma_first_ge")
                                                                                                                              (("1"
                                                                                                                                (inst
                                                                                                                                 -
                                                                                                                                 "(LAMBDA (n: upto(length(P!1) - 1)):
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Rie_sec(a!1, b!1, P!1, xis!1, f!1, n))"
                                                                                                                                 "N-1"
                                                                                                                                 "M_xh")
                                                                                                                                (("1"
                                                                                                                                  (assert)
                                                                                                                                  (("1"
                                                                                                                                    (replace
                                                                                                                                     -1)
                                                                                                                                    (("1"
                                                                                                                                      (hide
                                                                                                                                       -1)
                                                                                                                                      (("1"
                                                                                                                                        (case-replace
                                                                                                                                         "sigma(1 + M_xh, N - 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (LAMBDA (n: upto(length(P!1) - 1)):
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Rie_sec(a!1, b!1, P!1, xis!1, f!1, n))) = 0")
                                                                                                                                        (("1"
                                                                                                                                          (assert)
                                                                                                                                          (("1"
                                                                                                                                            (assert)
                                                                                                                                            (("1"
                                                                                                                                              (lemma
                                                                                                                                               "triangle")
                                                                                                                                              (("1"
                                                                                                                                                (inst
                                                                                                                                                 -1
                                                                                                                                                 "Rie_sec(a!1, b!1, P!1, xis!1, f!1, M_xh)"
                                                                                                                                                 "Rie_sec(a!1, b!1, P!1, xis!1, f!1, M_xh - 1)")
                                                                                                                                                (("1"
                                                                                                                                                  (assert)
                                                                                                                                                  nil
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil)
                                                                                                                                         ("2"
                                                                                                                                          (assert)
                                                                                                                                          (("2"
                                                                                                                                            (hide
                                                                                                                                             3)
                                                                                                                                            (("2"
                                                                                                                                              (case-replace
                                                                                                                                               "sigma(1 + M_xh, N - 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (LAMBDA (n: upto(length(P!1) - 1)):
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Rie_sec(a!1, b!1, P!1, xis!1, f!1, n)))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            = sigma(1+M_xh,N-1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             , (LAMBDA (n: upto(length(P!1) - 1)): 0))")
                                                                                                                                              (("1"
                                                                                                                                                (assert)
                                                                                                                                                (("1"
                                                                                                                                                  (rewrite
                                                                                                                                                   "sigma_const[upto(length(P!1) - 1)]")
                                                                                                                                                  (("1"
                                                                                                                                                    (skosimp*)
                                                                                                                                                    (("1"
                                                                                                                                                      (assert)
                                                                                                                                                      nil
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil)
                                                                                                                                               ("2"
                                                                                                                                                (hide
                                                                                                                                                 2)
                                                                                                                                                (("2"
                                                                                                                                                  (rewrite
                                                                                                                                                   "sigma_restrict_eq")
                                                                                                                                                  (("1"
                                                                                                                                                    (hide
                                                                                                                                                     2)
                                                                                                                                                    (("1"
                                                                                                                                                      (expand
                                                                                                                                                       "restrict")
                                                                                                                                                      (("1"
                                                                                                                                                        (apply-extensionality
                                                                                                                                                         1
                                                                                                                                                         :hide?
                                                                                                                                                         t)
                                                                                                                                                        (("1"
                                                                                                                                                          (lift-if)
                                                                                                                                                          (("1"
                                                                                                                                                            (ground)
                                                                                                                                                            (("1"
                                                                                                                                                              (expand
                                                                                                                                                               "Rie_sec")
                                                                                                                                                              (("1"
                                                                                                                                                                (assert)
                                                                                                                                                                (("1"
                                                                                                                                                                  (inst
                                                                                                                                                                   -
                                                                                                                                                                   "xis!1(x!1-1)")
                                                                                                                                                                  (("1"
                                                                                                                                                                    (assert)
                                                                                                                                                                    (("1"
                                                                                                                                                                      (case
                                                                                                                                                                       "xis!1(x!1-1) >= xh!1")
                                                                                                                                                                      (("1"
                                                                                                                                                                        (assert)
                                                                                                                                                                        nil
                                                                                                                                                                        nil)
                                                                                                                                                                       ("2"
                                                                                                                                                                        (hide
                                                                                                                                                                         -6)
                                                                                                                                                                        (("2"
                                                                                                                                                                          (typepred
                                                                                                                                                                           "xis!1(x!1-1)")
                                                                                                                                                                          (("2"
                                                                                                                                                                            (lemma
                                                                                                                                                                             "parts_order")
                                                                                                                                                                            (("2"
                                                                                                                                                                              (inst
                                                                                                                                                                               -1
                                                                                                                                                                               "a!1"
                                                                                                                                                                               "b!1"
                                                                                                                                                                               "P!1"
                                                                                                                                                                               "M_xh"
                                                                                                                                                                               "x!1-1")
                                                                                                                                                                              (("2"
                                                                                                                                                                                (assert)
                                                                                                                                                                                (("2"
                                                                                                                                                                                  (lemma
                                                                                                                                                                                   "xis_lem")
                                                                                                                                                                                  (("2"
                                                                                                                                                                                    (assert)
                                                                                                                                                                                    (("2"
                                                                                                                                                                                      (inst?)
                                                                                                                                                                                      (("2"
                                                                                                                                                                                        (flatten)
                                                                                                                                                                                        (("2"
                                                                                                                                                                                          (assert)
                                                                                                                                                                                          nil
                                                                                                                                                                                          nil))
                                                                                                                                                                                        nil))
                                                                                                                                                                                      nil))
                                                                                                                                                                                    nil))
                                                                                                                                                                                  nil))
                                                                                                                                                                                nil))
                                                                                                                                                                              nil))
                                                                                                                                                                            nil))
                                                                                                                                                                          nil))
                                                                                                                                                                        nil))
                                                                                                                                                                      nil))
                                                                                                                                                                    nil))
                                                                                                                                                                  nil))
                                                                                                                                                                nil))
                                                                                                                                                              nil))
                                                                                                                                                            nil))
                                                                                                                                                          nil))
                                                                                                                                                        nil))
                                                                                                                                                      nil))
                                                                                                                                                    nil)
                                                                                                                                                   ("2"
                                                                                                                                                    (skosimp*)
                                                                                                                                                    (("2"
                                                                                                                                                      (assert)
                                                                                                                                                      nil
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil)
                                                                                                                                               ("3"
                                                                                                                                                (skosimp*)
                                                                                                                                                (("3"
                                                                                                                                                  (assert)
                                                                                                                                                  nil
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil)
                                                                                                                                         ("3"
                                                                                                                                          (skosimp*)
                                                                                                                                          (("3"
                                                                                                                                            (assert)
                                                                                                                                            nil
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil)
                                                                                                                             ("2"
                                                                                                                              (typepred
                                                                                                                               "M_xh")
                                                                                                                              (("2"
                                                                                                                                (rewrite
                                                                                                                                 "sigma_rew"
                                                                                                                                 3)
                                                                                                                                (("1"
                                                                                                                                  (assert)
                                                                                                                                  (("1"
                                                                                                                                    (assert)
                                                                                                                                    (("1"
                                                                                                                                      (lemma
                                                                                                                                       "triangle")
                                                                                                                                      (("1"
                                                                                                                                        (inst
                                                                                                                                         -1
                                                                                                                                         "Rie_sec(a!1, b!1, P!1, xis!1, f!1, M_xh)"
                                                                                                                                         "Rie_sec(a!1, b!1, P!1, xis!1, f!1, M_xh - 1)")
                                                                                                                                        (("1"
                                                                                                                                          (assert)
                                                                                                                                          nil
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil)
                                                                                                                                 ("2"
                                                                                                                                  (skosimp*)
                                                                                                                                  (("2"
                                                                                                                                    (assert)
                                                                                                                                    nil
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil)
                                                                                                                 ("2"
                                                                                                                  (hide
                                                                                                                   3)
                                                                                                                  (("2"
                                                                                                                    (lemma
                                                                                                                     "EXse")
                                                                                                                    (("2"
                                                                                                                      (inst
                                                                                                                       -
                                                                                                                       "epsi!1/1000"
                                                                                                                       "a!1"
                                                                                                                       "b!1"
                                                                                                                       "f!1"
                                                                                                                       "M_xh-1"
                                                                                                                       "xh!1"
                                                                                                                       "xl!1")
                                                                                                                      (("2"
                                                                                                                        (assert)
                                                                                                                        (("2"
                                                                                                                          (inst?)
                                                                                                                          (("2"
                                                                                                                            (assert)
                                                                                                                            nil
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil)
                                                                                                               ("2"
                                                                                                                (hide
                                                                                                                 3)
                                                                                                                (("2"
                                                                                                                  (expand
                                                                                                                   "Rie_sec")
                                                                                                                  (("2"
                                                                                                                    (hide
                                                                                                                     -1)
                                                                                                                    (("2"
                                                                                                                      (assert)
                                                                                                                      (("2"
                                                                                                                        (case
                                                                                                                         "f!1(xis!1(M_xh - 1)) <= 1")
                                                                                                                        (("1"
                                                                                                                          (case
                                                                                                                           "P!1`seq(1 + (M_xh - 1)) - P!1`seq(M_xh - 1) < epsi!1 / 4")
                                                                                                                          (("1"
                                                                                                                            (mult-ineq
                                                                                                                             -1
                                                                                                                             -2)
                                                                                                                            (("1"
                                                                                                                              (case-replace
                                                                                                                               "f!1(xis!1(M_xh - 1)) >= 0")
                                                                                                                              (("1"
                                                                                                                                (hide-all-but
                                                                                                                                 (-1
                                                                                                                                  -2
                                                                                                                                  1))
                                                                                                                                (("1"
                                                                                                                                  (expand
                                                                                                                                   "abs")
                                                                                                                                  (("1"
                                                                                                                                    (lift-if)
                                                                                                                                    (("1"
                                                                                                                                      (case
                                                                                                                                       "seq(P!1)(M_xh) - seq(P!1)(M_xh - 1) > 0")
                                                                                                                                      (("1"
                                                                                                                                        (assert)
                                                                                                                                        (("1"
                                                                                                                                          (case
                                                                                                                                           "(seq(P!1)(M_xh) - seq(P!1)(M_xh - 1))* f!1(xis!1(M_xh - 1)) >= 0")
                                                                                                                                          (("1"
                                                                                                                                            (assert)
                                                                                                                                            nil
                                                                                                                                            nil)
                                                                                                                                           ("2"
                                                                                                                                            (hide
                                                                                                                                             -3
                                                                                                                                             2)
                                                                                                                                            (("2"
                                                                                                                                              (lemma
                                                                                                                                               "ge_times_ge_pos")
                                                                                                                                              (("2"
                                                                                                                                                (inst
                                                                                                                                                 -
                                                                                                                                                 "0"
                                                                                                                                                 "0"
                                                                                                                                                 "f!1(xis!1(M_xh - 1))"
                                                                                                                                                 "seq(P!1)(M_xh) - seq(P!1)(M_xh - 1)")
                                                                                                                                                (("2"
                                                                                                                                                  (assert)
                                                                                                                                                  nil
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil)
                                                                                                                                       ("2"
                                                                                                                                        (hide
                                                                                                                                         2)
                                                                                                                                        (("2"
                                                                                                                                          (assert)
                                                                                                                                          nil
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil)
                                                                                                                               ("2"
                                                                                                                                (inst
                                                                                                                                 -
                                                                                                                                 "xis!1(M_xh - 1)")
                                                                                                                                (("2"
                                                                                                                                  (assert)
                                                                                                                                  nil
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil)
                                                                                                                           ("2"
                                                                                                                            (assert)
                                                                                                                            (("2"
                                                                                                                              (lemma
                                                                                                                               "width_lem")
                                                                                                                              (("2"
                                                                                                                                (assert)
                                                                                                                                (("2"
                                                                                                                                  (inst
                                                                                                                                   -1
                                                                                                                                   "a!1"
                                                                                                                                   "b!1"
                                                                                                                                   "P!1"
                                                                                                                                   "M_xh-1")
                                                                                                                                  (("2"
                                                                                                                                    (assert)
                                                                                                                                    nil
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil)
                                                                                                                         ("2"
                                                                                                                          (hide
                                                                                                                           2)
                                                                                                                          (("2"
                                                                                                                            (inst
                                                                                                                             -
                                                                                                                             "xis!1(M_xh - 1)")
                                                                                                                            (("2"
                                                                                                                              (ground)
                                                                                                                              nil
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil)
                                                                                                           ("2"
                                                                                                            (hide
                                                                                                             3)
                                                                                                            (("2"
                                                                                                              (case-replace
                                                                                                               "sigma(1, M_xh - 2,
                                                                                                                                                                                                                                                                                                                                                                                                                                (LAMBDA (n: upto(length(P!1) - 1)):
                                                                                                                                                                                                                                                                                                                                                                                                                                   Rie_sec(a!1, b!1, P!1, xis!1, f!1, n))) = sigma(1, M_xh - 2,                                                                                                                                                                      (LAMBDA (n: upto(length(P!1) - 1)):
                                                                                                                                                                                                                                                                                                                                                                                                                                   0))")
                                                                                                              (("1"
                                                                                                                (assert)
                                                                                                                (("1"
                                                                                                                  (rewrite
                                                                                                                   "sigma_const[upto(length(P!1) - 1)]")
                                                                                                                  (("1"
                                                                                                                    (skosimp*)
                                                                                                                    (("1"
                                                                                                                      (assert)
                                                                                                                      nil
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil)
                                                                                                               ("2"
                                                                                                                (hide
                                                                                                                 2)
                                                                                                                (("2"
                                                                                                                  (rewrite
                                                                                                                   "sigma_restrict_eq")
                                                                                                                  (("1"
                                                                                                                    (hide
                                                                                                                     2)
                                                                                                                    (("1"
                                                                                                                      (expand
                                                                                                                       "restrict")
                                                                                                                      (("1"
                                                                                                                        (apply-extensionality
                                                                                                                         1
                                                                                                                         :hide?
                                                                                                                         t)
                                                                                                                        (("1"
                                                                                                                          (lift-if)
                                                                                                                          (("1"
                                                                                                                            (ground)
                                                                                                                            (("1"
                                                                                                                              (expand
                                                                                                                               "Rie_sec")
                                                                                                                              (("1"
                                                                                                                                (case
                                                                                                                                 "f!1(xis!1(x!1-1)) = 0")
                                                                                                                                (("1"
                                                                                                                                  (assert)
                                                                                                                                  nil
                                                                                                                                  nil)
                                                                                                                                 ("2"
                                                                                                                                  (assert)
                                                                                                                                  (("2"
                                                                                                                                    (hide
                                                                                                                                     4)
                                                                                                                                    (("2"
                                                                                                                                      (inst
                                                                                                                                       -
                                                                                                                                       "xis!1(x!1-1)")
                                                                                                                                      (("2"
                                                                                                                                        (assert)
                                                                                                                                        (("2"
                                                                                                                                          (ground)
                                                                                                                                          (("2"
                                                                                                                                            (lemma
                                                                                                                                             "parts_order")
                                                                                                                                            (("2"
                                                                                                                                              (inst
                                                                                                                                               -1
                                                                                                                                               "a!1"
                                                                                                                                               "b!1"
                                                                                                                                               "P!1"
                                                                                                                                               "x!1"
                                                                                                                                               "M_xh-2")
                                                                                                                                              (("2"
                                                                                                                                                (lemma
                                                                                                                                                 "xis_lem")
                                                                                                                                                (("2"
                                                                                                                                                  (assert)
                                                                                                                                                  (("2"
                                                                                                                                                    (inst?)
                                                                                                                                                    (("2"
                                                                                                                                                      (flatten)
                                                                                                                                                      (("2"
                                                                                                                                                        (assert)
                                                                                                                                                        nil
                                                                                                                                                        nil))
                                                                                                                                                      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)
                                                                                                               ("3"
                                                                                                                (skosimp*)
                                                                                                                (("3"
                                                                                                                  (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)
                                                                                 ("2"
                                                                                  (typepred
                                                                                   "P!1")
                                                                                  (("2"
                                                                                    (inst?)
                                                                                    (("2"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (assert)
                                                                                (("2"
                                                                                  (case-replace
                                                                                   "M_xh = 1")
                                                                                  (("1"
                                                                                    (replace
                                                                                     -3)
                                                                                    (("1"
                                                                                      (case
                                                                                       "3 <= length(P!1)")
                                                                                      (("1"
                                                                                        (assert)
                                                                                        (("1"
                                                                                          (lemma
                                                                                           "sigma_upto[length(P!1) - 1].sigma_first_ge")
                                                                                          (("1"
                                                                                            (inst
                                                                                             -
                                                                                             "(LAMBDA (n: upto(length(P!1) - 1)): Rie_sec(a!1, b!1,
                                                                                                                                                                                                           P!1, xis!1, f!1, n))"
                                                                                             "N-1"
                                                                                             "1")
                                                                                            (("1"
                                                                                              (assert)
                                                                                              (("1"
                                                                                                (replace
                                                                                                 -1)
                                                                                                (("1"
                                                                                                  (case-replace
                                                                                                   "sigma(2, N - 1,
                                                                                                                                                                                                                             (LAMBDA (n: upto(length(P!1) - 1)):
                                                                                                                                                                                                                                Rie_sec(a!1, b!1, P!1, xis!1, f!1, n))) = 0")
                                                                                                  (("1"
                                                                                                    (hide
                                                                                                     -1
                                                                                                     -2)
                                                                                                    (("1"
                                                                                                      (lemma
                                                                                                       "EXse")
                                                                                                      (("1"
                                                                                                        (inst
                                                                                                         -
                                                                                                         "epsi!1/1000"
                                                                                                         "a!1"
                                                                                                         "b!1"
                                                                                                         "f!1"
                                                                                                         "1"
                                                                                                         "xh!1"
                                                                                                         "xl!1")
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          (("1"
                                                                                                            (inst?)
                                                                                                            (("1"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil)
                                                                                                   ("2"
                                                                                                    (hide
                                                                                                     3
                                                                                                     4)
                                                                                                    (("2"
                                                                                                      (hide
                                                                                                       -1)
                                                                                                      (("2"
                                                                                                        (case-replace
                                                                                                         "sigma(2, N - 1, (LAMBDA (n: upto(length(P!1) - 1)):
                                                                                                                                                                                                                                                       Rie_sec(a!1, b!1, P!1, xis!1, f!1, n))) = sigma(2,N-1 , (LAMBDA (n:
                                                                                                                                                                                                                                                       upto(length(P!1) - 1)): 0))")
                                                                                                        (("1"
                                                                                                          (rewrite
                                                                                                           "sigma_const[upto(length(P!1) - 1)]")
                                                                                                          (("1"
                                                                                                            (skosimp*)
                                                                                                            (("1"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (hide
                                                                                                           2)
                                                                                                          (("2"
                                                                                                            (rewrite
                                                                                                             "sigma_restrict_eq")
                                                                                                            (("1"
                                                                                                              (hide
                                                                                                               2)
                                                                                                              (("1"
                                                                                                                (expand
                                                                                                                 "restrict")
                                                                                                                (("1"
                                                                                                                  (apply-extensionality
                                                                                                                   1
                                                                                                                   :hide?
                                                                                                                   t)
                                                                                                                  (("1"
                                                                                                                    (lift-if)
                                                                                                                    (("1"
                                                                                                                      (ground)
                                                                                                                      (("1"
                                                                                                                        (case-replace
                                                                                                                         "x!1 - 1 >= M_xh")
                                                                                                                        (("1"
                                                                                                                          (expand
                                                                                                                           "Rie_sec")
                                                                                                                          (("1"
                                                                                                                            (assert)
                                                                                                                            (("1"
                                                                                                                              (inst
                                                                                                                               -
                                                                                                                               "xis!1(x!1-1)")
                                                                                                                              (("1"
                                                                                                                                (assert)
                                                                                                                                (("1"
                                                                                                                                  (case-replace
                                                                                                                                   "xis!1(x!1-1) >= xh!1")
                                                                                                                                  (("1"
                                                                                                                                    (ground)
                                                                                                                                    nil
                                                                                                                                    nil)
                                                                                                                                   ("2"
                                                                                                                                    (hide
                                                                                                                                     3)
                                                                                                                                    (("2"
                                                                                                                                      (lemma
                                                                                                                                       "parts_order")
                                                                                                                                      (("2"
                                                                                                                                        (inst
                                                                                                                                         -
                                                                                                                                         "a!1"
                                                                                                                                         "b!1"
                                                                                                                                         "P!1"
                                                                                                                                         "M_xh"
                                                                                                                                         "x!1-1")
                                                                                                                                        (("2"
                                                                                                                                          (assert)
                                                                                                                                          (("2"
                                                                                                                                            (lemma
                                                                                                                                             "xis_lem")
                                                                                                                                            (("2"
                                                                                                                                              (assert)
                                                                                                                                              (("2"
                                                                                                                                                (inst?)
                                                                                                                                                (("2"
                                                                                                                                                  (flatten)
                                                                                                                                                  (("2"
                                                                                                                                                    (assert)
                                                                                                                                                    nil
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil)
                                                                                                                         ("2"
                                                                                                                          (assert)
                                                                                                                          nil
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil)
                                                                                                             ("2"
                                                                                                              (skosimp*)
                                                                                                              (("2"
                                                                                                                (assert)
                                                                                                                nil
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil)
                                                                                                         ("3"
                                                                                                          (skosimp*)
                                                                                                          (("3"
                                                                                                            (assert)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil)
                                                                                                   ("3"
                                                                                                    (skosimp*)
                                                                                                    (("3"
                                                                                                      (assert)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (rewrite
                                                                                         "sigma_rew")
                                                                                        (("1"
                                                                                          (lemma
                                                                                           "EXse")
                                                                                          (("1"
                                                                                            (inst
                                                                                             -
                                                                                             "epsi!1/1000"
                                                                                             "a!1"
                                                                                             "b!1"
                                                                                             "f!1"
                                                                                             "1"
                                                                                             "xh!1"
                                                                                             "xl!1")
                                                                                            (("1"
                                                                                              (assert)
                                                                                              (("1"
                                                                                                (inst?)
                                                                                                (("1"
                                                                                                  (assert)
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (skosimp*)
                                                                                          (("2"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil)
                                                                                   ("2"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (expand
                                                                               "nonempty?")
                                                                              (("2"
                                                                                (expand
                                                                                 "empty?")
                                                                                (("2"
                                                                                  (expand
                                                                                   "member")
                                                                                  (("2"
                                                                                    (inst
                                                                                     -1
                                                                                     "N-1")
                                                                                    (("2"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (expand
                                                             "abs"
                                                             1)
                                                            (("2"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (assert)
                                                    (("2"
                                                      (hide 3)
                                                      (("2"
                                                        (name
                                                         "M_xh"
                                                         "min_nat.min({j: below(N) | seq(P!1)(j) >= xh!1})")
                                                        (("1"
                                                          (case
                                                           "M_xh = 1")
                                                          (("1"
                                                            (case
                                                             "xh!1 - xl!1 <=seq(P!1)(M_xh) - seq(P!1)(0)")
                                                            (("1"
                                                              (expand
                                                               "abs"
                                                               1)
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (lemma
                                                                   "width_lem")
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (inst-cp
                                                                       -
                                                                       "a!1"
                                                                       "b!1"
                                                                       "P!1"
                                                                       "M_xh-1")
                                                                      (("1"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (assert)
                                                              nil
                                                              nil)
                                                             ("3"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (inst
                                                             +
                                                             "M_xh-2")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (typepred
                                                                 "M_xh")
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (inst
                                                                     -
                                                                     "M_xh-1")
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (expand
                                                                         "abs"
                                                                         3)
                                                                        (("1"
                                                                          (case
                                                                           "xh!1 - xl!1 <=seq(P!1)(M_xh) - seq(P!1)(M_xh-2)")
                                                                          (("1"
                                                                            (lemma
                                                                             "width_lem")
                                                                            (("1"
                                                                              (assert)
                                                                              (("1"
                                                                                (inst-cp
                                                                                 -
                                                                                 "a!1"
                                                                                 "b!1"
                                                                                 "P!1"
                                                                                 "M_xh-2")
                                                                                (("1"
                                                                                  (inst-cp
                                                                                   -
                                                                                   "a!1"
                                                                                   "b!1"
                                                                                   "P!1"
                                                                                   "M_xh-1")
                                                                                  (("1"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (assert)
                                                                            nil
                                                                            nil)
                                                                           ("3"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (expand
                                                           "nonempty?")
                                                          (("2"
                                                            (expand
                                                             "empty?")
                                                            (("2"
                                                              (expand
                                                               "member")
                                                              (("2"
                                                                (inst
                                                                 -1
                                                                 "N-1")
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("3" (assertnil nil)
                                             ("4"
                                              (skosimp*)
                                              (("4" (assertnil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((real_minus_real_is_real application-judgement "real" reals nil)
    (integral_def formula-decl nil integral_def nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields 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_pulse nil)
    (T formal-subtype-decl nil integral_pulse nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (Rie_sum_alt_lem formula-decl nil integral_def nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (triangle formula-decl nil real_props nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (EXse formula-decl nil integral_pulse nil)
    (sigma_first_ge formula-decl nil sigma_upto "reals/")
    (sigma_rew formula-decl nil sigma "reals/")
    (ge_times_ge_pos formula-decl nil real_props nil)
    (lt_times_lt_any1 formula-decl nil extra_real_props nil)
    (abs_nat formula-decl nil abs_lems "reals/")
    (posreal_times_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (M_xh skolem-const-decl "{a |
         seq(P!1)(a) >= xh!1 AND
          (FORALL (x: below(N)): seq(P!1)(x) >= xh!1 IMPLIES a <= x)}"
     integral_pulse nil)
    (xh!1 skolem-const-decl "T" integral_pulse nil)
    (N skolem-const-decl "nat" integral_pulse nil)
    (nnreal_times_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (nzint_abs_is_pos application-judgement "{j: posint | j >= i}"
     real_defs nil)
    (abs_mult formula-decl nil real_props nil)
    (nnreal_plus_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (M_xh skolem-const-decl "{a |
         seq(P!1)(a) >= xh!1 AND
          (FORALL (x: below(N)): seq(P!1)(x) >= xh!1 IMPLIES a <= x)}"
     integral_pulse nil)
    (Rie_sum const-decl "real" integral_def nil)
    (set type-eq-decl nil sets nil)
    (nonempty? const-decl "bool" sets nil)
    (min const-decl "{a | S(a) AND (FORALL x: S(x) IMPLIES a <= x)}"
         min_nat nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil)
    (Rie_sec const-decl "real" integral_def nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (T_low type-eq-decl nil sigma "reals/")
    (T_high type-eq-decl nil sigma "reals/")
    (sigma def-decl "real" sigma "reals/")
    (integer nonempty-type-from-decl nil integers nil)
    (EX3p formula-decl nil integral_pulse nil)
    (sigma_le formula-decl nil sigma "reals/")
    (subrange type-eq-decl nil integers nil)
    (both_sides_times_pos_le1_imp formula-decl nil extra_real_props
     nil)
    (n!1 skolem-const-decl "subrange(p!1, q!1)" integral_pulse nil)
    (q!1 skolem-const-decl "nat" integral_pulse nil)
    (p!1 skolem-const-decl "nat" integral_pulse nil)
    (P!1 skolem-const-decl "partition[T](a!1, b!1)" integral_pulse nil)
    (b!1 skolem-const-decl "T" integral_pulse nil)
    (a!1 skolem-const-decl "T" integral_pulse nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (finseq_appl const-decl "[below[length(fs)] -> T]" finite_sequences
     nil)
    (minus_real_is_real application-judgement "real" reals nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (width_lem formula-decl nil integral_def nil)
    (abs_neg formula-decl nil abs_lems "reals/")
    (SEC skolem-const-decl "[upto(length(P!1) - 1) -> numfield]"
     integral_pulse nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (xis_lem formula-decl nil integral_def nil)
    (parts_order formula-decl nil integral_def nil)
    (restrict const-decl "[T -> real]" sigma "reals/")
    (sigma_restrict_eq formula-decl nil sigma "reals/")
    (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)
    (sigma_const formula-decl nil sigma "reals/")
    (sigma_nat application-judgement "nat" sigma_upto "reals/")
    (sigma_split_ge formula-decl nil sigma_upto "reals/")
    (sigma_nonneg formula-decl nil sigma "reals/")
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (upto nonempty-type-eq-decl nil nat_types nil)
    (Rie_sum_alt const-decl "real" integral_def nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (xis? const-decl "bool" integral_def nil)
    (NOT const-decl "[bool -> bool]" 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)
    (= 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)
    (below type-eq-decl nil naturalnumbers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (Riemann_sum? const-decl "bool" integral_def nil)
    (closed_interval type-eq-decl nil intervals_real "reals/")
    (finite_sequence type-eq-decl nil finite_sequences nil)
    (partition type-eq-decl nil integral_def 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)
    (/= const-decl "boolean" notequal nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (posreal_div_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (integral? const-decl "bool" integral_def nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (real_times_real_is_real application-judgement "real" reals nil))
   nil)
  (Example_3-4 nil 3280253494
   ("" (skosimp*)
    (("" (rewrite "integral_def")
      (("" (expand "integral?")
        (("" (skosimp*)
          (("" (inst + "epsi!1/1000")
            (("" (skosimp*)
              (("" (typepred "R!1")
                (("" (expand "Riemann_sum?")
                  (("" (skosimp*)
                    (("" (replace -1)
                      (("" (hide -1)
                        (("" (lemma "Rie_sum_alt_lem")
                          (("" (inst - "a!1" "b!1" "f!1")
                            (("" (assert)
                              ((""
                                (inst?)
                                ((""
                                  (replace -1)
                                  ((""
                                    (hide -1)
                                    ((""
                                      (name "N" "length(P!1)")
                                      ((""
                                        (case
                                         "(EXISTS (k: below(N-1)): xl!1 < seq(P!1)(k) AND seq(P!1)(k+1) < xh!1)")
                                        (("1"
                                          (skosimp*)
                                          (("1"
                                            (case
                                             "EXISTS (p,q: nat): p >= 1 AND p <= length(P!1) -1
                                                                                                                                                                  AND seq(P!1)(p-1) <= xl!1 AND xl!1 < seq(P!1)(p)
                                                                                                                                                                  AND    q >=  1 AND q <= length(P!1) - 1
                                                                                                                                                                  AND seq(P!1)(q-1) < xh!1 AND xh!1 <= seq(P!1)(q) AND p+1 <= q-1")
                                            (("1"
                                              (skosimp*)
                                              (("1"
                                                (expand "Rie_sum_alt")
                                                (("1"
                                                  (expand "Rie_sec")
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (name
                                                       "SEC"
                                                       "       LAMBDA (n: upto(length(P!1) - 1)):
                                                                                                                                                                                                                                                                                                                                                                       IF n = 0 THEN 0
                                                                                                                                                                                                                                                                                                                                                                       ELSE seq(P!1)(n) *
                                                                                                                                                                                                                                                                                                                           f!1(xis!1(n - 1))
                                                                                                                                                                                                                                                                                                                                                                             -
                                                                                                                                                                                                                                                                                                                                                                             seq(P!1)(n - 1) *
                                                                                                                                                                                                                                                                                                                                                                              f!1(xis!1(n - 1))
                                                                                                                                                                                                                                                                                                                                                                       ENDIF")
                                                      (("1"
                                                        (replace -1)
                                                        (("1"
                                                          (name
                                                           "SS"
                                                           "sigma[upto(length(P!1) - 1)](1, length(P!1) - 1, SEC)")
                                                          (("1"
                                                            (replace
                                                             -1)
                                                            (("1"
                                                              (case
                                                               "sigma(p!1+1,q!1-1,SEC) <= SS AND SS <= sigma(p!1,q!1,SEC)")
                                                              (("1"
                                                                (flatten)
                                                                (("1"
                                                                  (case
                                                                   "sigma(p!1+1, q!1 - 1, SEC) = seq(P!1)(q!1-1) - seq(P!1)(p!1)")
                                                                  (("1"
                                                                    (case
                                                                     "sigma(p!1, q!1, SEC) <= seq(P!1)(q!1) - seq(P!1)(p!1-1)")
                                                                    (("1"
                                                                      (case-replace
                                                                       "abs(-1 * SS - xl!1 + xh!1) = abs(SS - xh!1 + xl!1)")
                                                                      (("1"
                                                                        (hide
                                                                         -1)
                                                                        (("1"
                                                                          (expand
                                                                           "abs")
                                                                          (("1"
                                                                            (lift-if)
                                                                            (("1"
                                                                              (hide
                                                                               -6
                                                                               -22)
                                                                              (("1"
                                                                                (lemma
                                                                                 "width_lem")
                                                                                (("1"
                                                                                  (expand
                                                                                   "finseq_appl")
                                                                                  (("1"
                                                                                    (inst-cp
                                                                                     -
                                                                                     "a!1"
                                                                                     "b!1"
                                                                                     "P!1"
                                                                                     "p!1-1")
                                                                                    (("1"
                                                                                      (inst-cp
                                                                                       -
                                                                                       "a!1"
                                                                                       "b!1"
                                                                                       "P!1"
                                                                                       "p!1")
                                                                                      (("1"
                                                                                        (inst
                                                                                         -
                                                                                         "a!1"
                                                                                         "b!1"
                                                                                         "P!1"
                                                                                         "q!1-1")
                                                                                        (("1"
                                                                                          (ground)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (assert)
                                                                        (("2"
                                                                          (hide-all-but
                                                                           1)
                                                                          (("2"
                                                                            (expand
                                                                             "abs")
                                                                            (("2"
                                                                              (lift-if)
                                                                              (("2"
                                                                                (lift-if)
                                                                                (("2"
                                                                                  (split)
                                                                                  (("1"
                                                                                    (flatten)
                                                                                    (("1"
                                                                                      (ground)
                                                                                      nil
                                                                                      nil))
                                                                                    nil)
                                                                                   ("2"
                                                                                    (flatten)
                                                                                    (("2"
                                                                                      (split
                                                                                       +)
                                                                                      (("1"
                                                                                        (flatten)
                                                                                        (("1"
                                                                                          (assert)
                                                                                          nil
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (flatten)
                                                                                        (("2"
                                                                                          (name
                                                                                           "AAAA"
                                                                                           "SS - xh!1 + xl!1")
                                                                                          (("2"
                                                                                            (replace
                                                                                             -1)
                                                                                            (("2"
                                                                                              (mult-by
                                                                                               -1
                                                                                               "-1")
                                                                                              (("2"
                                                                                                (replace
                                                                                                 -1)
                                                                                                (("2"
                                                                                                  (hide
                                                                                                   -1)
                                                                                                  (("2"
                                                                                                    (assert)
                                                                                                    nil
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (lemma
                                                                       "EX3p")
                                                                      (("2"
                                                                        (inst
                                                                         -1
                                                                         "a!1"
                                                                         "b!1")
                                                                        (("2"
                                                                          (inst?)
                                                                          (("2"
                                                                            (assert)
                                                                            (("2"
                                                                              (inst
                                                                               -1
                                                                               "P!1"
                                                                               "p!1"
                                                                               "q!1")
                                                                              (("2"
                                                                                (assert)
                                                                                (("2"
                                                                                  (assert)
                                                                                  (("2"
                                                                                    (replace
                                                                                     -1
                                                                                     +
                                                                                     rl)
                                                                                    (("2"
                                                                                      (rewrite
                                                                                       "sigma_le")
                                                                                      (("1"
                                                                                        (hide
                                                                                         2)
                                                                                        (("1"
                                                                                          (skosimp*)
                                                                                          (("1"
                                                                                            (replace
                                                                                             -6
                                                                                             +
                                                                                             rl)
                                                                                            (("1"
                                                                                              (assert)
                                                                                              (("1"
                                                                                                (hide
                                                                                                 -1
                                                                                                 -2
                                                                                                 -3
                                                                                                 -4
                                                                                                 -5
                                                                                                 -6)
                                                                                                (("1"
                                                                                                  (case
                                                                                                   "f!1(xis!1(n!1 - 1)) <= 1")
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    (("1"
                                                                                                      (mult-by
                                                                                                       -1
                                                                                                       "seq(P!1)(n!1) - seq(P!1)(n!1 - 1)")
                                                                                                      (("1"
                                                                                                        (assert)
                                                                                                        nil
                                                                                                        nil)
                                                                                                       ("2"
                                                                                                        (hide
                                                                                                         2)
                                                                                                        (("2"
                                                                                                          (typepred
                                                                                                           "xis!1")
                                                                                                          (("2"
                                                                                                            (assert)
                                                                                                            (("2"
                                                                                                              (inst
                                                                                                               -
                                                                                                               "n!1-1")
                                                                                                              (("2"
                                                                                                                (assert)
                                                                                                                (("2"
                                                                                                                  (flatten)
                                                                                                                  (("2"
                                                                                                                    (assert)
                                                                                                                    nil
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil)
                                                                                                   ("2"
                                                                                                    (hide
                                                                                                     2)
                                                                                                    (("2"
                                                                                                      (reveal
                                                                                                       -8)
                                                                                                      (("2"
                                                                                                        (inst
                                                                                                         -
                                                                                                         "xis!1(n!1 - 1)")
                                                                                                        (("2"
                                                                                                          (assert)
                                                                                                          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))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (lemma
                                                                     "EX3p")
                                                                    (("2"
                                                                      (inst
                                                                       -1
                                                                       "a!1"
                                                                       "b!1")
                                                                      (("2"
                                                                        (assert)
                                                                        (("2"
                                                                          (inst
                                                                           -1
                                                                           "P!1"
                                                                           "p!1+1"
                                                                           "q!1-1")
                                                                          (("2"
                                                                            (assert)
                                                                            (("2"
                                                                              (case
                                                                               "1 + p!1 <= q!1 - 1")
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (hide
                                                                                   2)
                                                                                  (("1"
                                                                                    (replace
                                                                                     -2
                                                                                     +
                                                                                     rl)
                                                                                    (("1"
                                                                                      (hide
                                                                                       -2)
                                                                                      (("1"
                                                                                        (rewrite
                                                                                         "sigma_restrict_eq")
                                                                                        (("1"
                                                                                          (hide
                                                                                           2)
                                                                                          (("1"
                                                                                            (expand
                                                                                             "restrict")
                                                                                            (("1"
                                                                                              (apply-extensionality
                                                                                               1
                                                                                               :hide?
                                                                                               t)
                                                                                              (("1"
                                                                                                (lift-if)
                                                                                                (("1"
                                                                                                  (ground)
                                                                                                  (("1"
                                                                                                    (replace
                                                                                                     -5
                                                                                                     +
                                                                                                     rl)
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      (("1"
                                                                                                        (inst
                                                                                                         -
                                                                                                         "xis!1(x!1 - 1)")
                                                                                                        (("1"
                                                                                                          (hide
                                                                                                           -2
                                                                                                           -3
                                                                                                           -4
                                                                                                           -5)
                                                                                                          (("1"
                                                                                                            (lemma
                                                                                                             "parts_order")
                                                                                                            (("1"
                                                                                                              (inst-cp
                                                                                                               -1
                                                                                                               "a!1"
                                                                                                               "b!1"
                                                                                                               "P!1"
                                                                                                               "p!1"
                                                                                                               "x!1-1")
                                                                                                              (("1"
                                                                                                                (inst-cp
                                                                                                                 -1
                                                                                                                 "a!1"
                                                                                                                 "b!1"
                                                                                                                 "P!1"
                                                                                                                 "x!1"
                                                                                                                 "q!1-1")
                                                                                                                (("1"
                                                                                                                  (hide
                                                                                                                   -1)
                                                                                                                  (("1"
                                                                                                                    (typepred
                                                                                                                     "xis!1")
                                                                                                                    (("1"
                                                                                                                      (expand
                                                                                                                       "xis?")
                                                                                                                      (("1"
                                                                                                                        (assert)
                                                                                                                        (("1"
                                                                                                                          (lemma
                                                                                                                           "xis_lem")
                                                                                                                          (("1"
                                                                                                                            (assert)
                                                                                                                            (("1"
                                                                                                                              (inst?)
                                                                                                                              (("1"
                                                                                                                                (flatten)
                                                                                                                                (("1"
                                                                                                                                  (ground)
                                                                                                                                  nil
                                                                                                                                  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)
                                                                                         ("2"
                                                                                          (skosimp*)
                                                                                          (("2"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (propax)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (assert)
                                                                (("2"
                                                                  (assert)
                                                                  (("2"
                                                                    (hide
                                                                     2)
                                                                    (("2"
                                                                      (replace
                                                                       -14)
                                                                      (("2"
                                                                        (prop)
                                                                        (("1"
                                                                          (lemma
                                                                           "sigma_split_ge[length(P!1) - 1]")
                                                                          (("1"
                                                                            (inst
                                                                             -1
                                                                             "_"
                                                                             "N-1"
                                                                             "1"
                                                                             "p!1")
                                                                            (("1"
                                                                              (inst?)
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (replace
                                                                                   -1)
                                                                                  (("1"
                                                                                    (hide
                                                                                     -1)
                                                                                    (("1"
                                                                                      (lemma
                                                                                       "sigma_split_ge[length(P!1) - 1]")
                                                                                      (("1"
                                                                                        (inst
                                                                                         -1
                                                                                         "_"
                                                                                         "N-1"
                                                                                         "1+p!1"
                                                                                         "q!1-1")
                                                                                        (("1"
                                                                                          (inst?)
                                                                                          (("1"
                                                                                            (assert)
                                                                                            (("1"
                                                                                              (replace
                                                                                               -1)
                                                                                              (("1"
                                                                                                (case-replace
                                                                                                 "sigma(q!1, N - 1, SEC) >= 0 AND sigma(1, p!1, SEC) >= 0")
                                                                                                (("1"
                                                                                                  (flatten)
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    nil
                                                                                                    nil))
                                                                                                  nil)
                                                                                                 ("2"
                                                                                                  (hide
                                                                                                   2)
                                                                                                  (("2"
                                                                                                    (lemma
                                                                                                     "sigma_nonneg[upto(length(P!1)-1)]")
                                                                                                    (("2"
                                                                                                      (case
                                                                                                       "(FORALL (i: upto(length(P!1) - 1)): SEC(i) >= 0)")
                                                                                                      (("1"
                                                                                                        (inst-cp
                                                                                                         -2
                                                                                                         "SEC"
                                                                                                         "N-1"
                                                                                                         "q!1")
                                                                                                        (("1"
                                                                                                          (inst
                                                                                                           -2
                                                                                                           "SEC"
                                                                                                           "p!1"
                                                                                                           "1")
                                                                                                          (("1"
                                                                                                            (assert)
                                                                                                            (("1"
                                                                                                              (replace
                                                                                                               -1)
                                                                                                              (("1"
                                                                                                                (assert)
                                                                                                                nil
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil)
                                                                                                       ("2"
                                                                                                        (skosimp*)
                                                                                                        (("2"
                                                                                                          (hide
                                                                                                           2)
                                                                                                          (("2"
                                                                                                            (replace
                                                                                                             -4
                                                                                                             +
                                                                                                             rl)
                                                                                                            (("2"
                                                                                                              (assert)
                                                                                                              (("2"
                                                                                                                (hide
                                                                                                                 -1
                                                                                                                 -2
                                                                                                                 -3
                                                                                                                 -4)
                                                                                                                (("2"
                                                                                                                  (lift-if)
                                                                                                                  (("2"
                                                                                                                    (ground)
                                                                                                                    (("2"
                                                                                                                      (inst
                                                                                                                       -
                                                                                                                       "xis!1(i!1 - 1)")
                                                                                                                      (("2"
                                                                                                                        (lemma
                                                                                                                         "xis_lem")
                                                                                                                        (("2"
                                                                                                                          (assert)
                                                                                                                          (("2"
                                                                                                                            (inst?)
                                                                                                                            (("2"
                                                                                                                              (flatten)
                                                                                                                              (("2"
                                                                                                                                (ground)
                                                                                                                                nil
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil)
                                                                                                 ("3"
                                                                                                  (flatten)
                                                                                                  (("3"
                                                                                                    (skosimp*)
                                                                                                    (("3"
                                                                                                      (assert)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (assert)
                                                                          (("2"
                                                                            (lemma
                                                                             "sigma_split_ge[length(P!1) - 1]")
                                                                            (("2"
                                                                              (inst
                                                                               -1
                                                                               "_"
                                                                               "N-1"
                                                                               "1"
                                                                               "p!1-1")
                                                                              (("2"
                                                                                (inst?)
                                                                                (("2"
                                                                                  (assert)
                                                                                  (("2"
                                                                                    (replace
                                                                                     -1)
                                                                                    (("2"
                                                                                      (hide
                                                                                       -1)
                                                                                      (("2"
                                                                                        (case-replace
                                                                                         "sigma(1, p!1 - 1, SEC) = 0")
                                                                                        (("1"
                                                                                          (assert)
                                                                                          (("1"
                                                                                            (hide
                                                                                             -1)
                                                                                            (("1"
                                                                                              (lemma
                                                                                               "sigma_split_ge[length(P!1) - 1]")
                                                                                              (("1"
                                                                                                (inst
                                                                                                 -1
                                                                                                 "_"
                                                                                                 "N-1"
                                                                                                 "p!1"
                                                                                                 "q!1")
                                                                                                (("1"
                                                                                                  (inst?)
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    (("1"
                                                                                                      (replace
                                                                                                       -1)
                                                                                                      (("1"
                                                                                                        (hide
                                                                                                         -1)
                                                                                                        (("1"
                                                                                                          (case-replace
                                                                                                           "sigma(1 + q!1, N - 1, SEC) = 0")
                                                                                                          (("1"
                                                                                                            (assert)
                                                                                                            nil
                                                                                                            nil)
                                                                                                           ("2"
                                                                                                            (hide
                                                                                                             -1)
                                                                                                            (("2"
                                                                                                              (hide
                                                                                                               2)
                                                                                                              (("2"
                                                                                                                (case-replace
                                                                                                                 "sigma(1+q!1,N-1, SEC) = sigma(1+q!1,N-1,(LAMBDA (n: upto(length(P!1) - 1)): 0))")
                                                                                                                (("1"
                                                                                                                  (rewrite
                                                                                                                   "sigma_const")
                                                                                                                  nil
                                                                                                                  nil)
                                                                                                                 ("2"
                                                                                                                  (hide
                                                                                                                   2)
                                                                                                                  (("2"
                                                                                                                    (rewrite
                                                                                                                     "sigma_restrict_eq")
                                                                                                                    (("2"
                                                                                                                      (hide
                                                                                                                       2)
                                                                                                                      (("2"
                                                                                                                        (expand
                                                                                                                         "restrict")
                                                                                                                        (("2"
                                                                                                                          (apply-extensionality
                                                                                                                           1
                                                                                                                           :hide?
                                                                                                                           t)
                                                                                                                          (("2"
                                                                                                                            (lift-if)
                                                                                                                            (("2"
                                                                                                                              (ground)
                                                                                                                              (("2"
                                                                                                                                (replace
                                                                                                                                 -1
                                                                                                                                 +
                                                                                                                                 rl)
                                                                                                                                (("2"
                                                                                                                                  (assert)
                                                                                                                                  (("2"
                                                                                                                                    (inst
                                                                                                                                     -
                                                                                                                                     "xis!1(x!1 - 1)")
                                                                                                                                    (("2"
                                                                                                                                      (case
                                                                                                                                       "xis!1(x!1 - 1) >= xh!1")
                                                                                                                                      (("1"
                                                                                                                                        (assert)
                                                                                                                                        nil
                                                                                                                                        nil)
                                                                                                                                       ("2"
                                                                                                                                        (assert)
                                                                                                                                        (("2"
                                                                                                                                          (typepred
                                                                                                                                           "xis!1")
                                                                                                                                          (("2"
                                                                                                                                            (assert)
                                                                                                                                            (("2"
                                                                                                                                              (lemma
                                                                                                                                               "parts_order")
                                                                                                                                              (("2"
                                                                                                                                                (inst-cp
                                                                                                                                                 -1
                                                                                                                                                 "a!1"
                                                                                                                                                 "b!1"
                                                                                                                                                 "P!1"
                                                                                                                                                 "q!1-1"
                                                                                                                                                 "x!1")
                                                                                                                                                (("2"
                                                                                                                                                  (inst-cp
                                                                                                                                                   -1
                                                                                                                                                   "a!1"
                                                                                                                                                   "b!1"
                                                                                                                                                   "P!1"
                                                                                                                                                   "q!1"
                                                                                                                                                   "x!1")
                                                                                                                                                  (("2"
                                                                                                                                                    (inst-cp
                                                                                                                                                     -1
                                                                                                                                                     "a!1"
                                                                                                                                                     "b!1"
                                                                                                                                                     "P!1"
                                                                                                                                                     "q!1+1"
                                                                                                                                                     "x!1")
                                                                                                                                                    (("2"
                                                                                                                                                      (assert)
                                                                                                                                                      (("2"
                                                                                                                                                        (inst
                                                                                                                                                         -1
                                                                                                                                                         "a!1"
                                                                                                                                                         "b!1"
                                                                                                                                                         "P!1"
                                                                                                                                                         "q!1"
                                                                                                                                                         "x!1-1")
                                                                                                                                                        (("2"
                                                                                                                                                          (lemma
                                                                                                                                                           "xis_lem")
                                                                                                                                                          (("2"
                                                                                                                                                            (inst
                                                                                                                                                             -1
                                                                                                                                                             "a!1"
                                                                                                                                                             "b!1"
                                                                                                                                                             "P!1"
                                                                                                                                                             "xis!1"
                                                                                                                                                             "x!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))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (case-replace
                                                                                           "sigma(1, p!1 - 1, SEC) = sigma(1,p!1-1,(LAMBDA (n: upto(length(P!1) - 1)): 0))")
                                                                                          (("1"
                                                                                            (hide
                                                                                             -1
                                                                                             -2
                                                                                             -3)
                                                                                            (("1"
                                                                                              (rewrite
                                                                                               "sigma_const")
                                                                                              nil
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (rewrite
                                                                                             "sigma_restrict_eq")
                                                                                            (("2"
                                                                                              (expand
                                                                                               "restrict")
                                                                                              (("2"
                                                                                                (apply-extensionality
                                                                                                 1
                                                                                                 :hide?
                                                                                                 t)
                                                                                                (("2"
                                                                                                  (lift-if)
                                                                                                  (("2"
                                                                                                    (ground)
                                                                                                    (("2"
                                                                                                      (hide
                                                                                                       4
                                                                                                       5
                                                                                                       6)
                                                                                                      (("2"
                                                                                                        (replace
                                                                                                         -2
                                                                                                         +
                                                                                                         rl)
                                                                                                        (("2"
                                                                                                          (assert)
                                                                                                          (("2"
                                                                                                            (inst
                                                                                                             -
                                                                                                             "xis!1(x!1-1)")
                                                                                                            (("2"
                                                                                                              (case
                                                                                                               "xl!1 >= xis!1(x!1-1)")
                                                                                                              (("1"
                                                                                                                (ground)
                                                                                                                nil
                                                                                                                nil)
                                                                                                               ("2"
                                                                                                                (typepred
                                                                                                                 "xis!1")
                                                                                                                (("2"
                                                                                                                  (assert)
                                                                                                                  (("2"
                                                                                                                    (hide
                                                                                                                     4)
                                                                                                                    (("2"
                                                                                                                      (lemma
                                                                                                                       "parts_order")
                                                                                                                      (("2"
                                                                                                                        (inst-cp
                                                                                                                         -1
                                                                                                                         "a!1"
                                                                                                                         "b!1"
                                                                                                                         "P!1"
                                                                                                                         "x!1"
                                                                                                                         "p!1-1")
                                                                                                                        (("2"
                                                                                                                          (assert)
                                                                                                                          (("2"
                                                                                                                            (lemma
                                                                                                                             "xis_lem")
                                                                                                                            (("2"
                                                                                                                              (inst
                                                                                                                               -1
                                                                                                                               "a!1"
                                                                                                                               "b!1"
                                                                                                                               "P!1"
                                                                                                                               "xis!1"
                                                                                                                               "x!1-1")
                                                                                                                              (("2"
                                                                                                                                (assert)
                                                                                                                                (("2"
                                                                                                                                  (flatten)
                                                                                                                                  (("2"
                                                                                                                                    (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))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("3"
                                                                (flatten)
                                                                (("3"
                                                                  (skosimp*)
                                                                  (("3"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (skosimp*)
                                                            (("2"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (skosimp*)
                                                        (("2"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil)
                                                       ("3"
                                                        (skosimp*)
                                                        (("3"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (name
                                               "M_xl"
                                               "min_nat.min({j: below(N) | seq(P!1)(j) > xl!1})")
                                              (("1"
                                                (name
                                                 "M_xh"
                                                 "min_nat.min({j: below(N) | seq(P!1)(j) >= xh!1})")
                                                (("1"
                                                  (inst
                                                   +
                                                   "M_xl"
                                                   "M_xh")
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (typepred "M_xh")
                                                      (("1"
                                                        (inst
                                                         -
                                                         "M_xh-1")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (typepred
                                                             "M_xl")
                                                            (("1"
                                                              (typepred
                                                               "M_xl")
                                                              (("1"
                                                                (inst
                                                                 -
                                                                 "M_xl-1")
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (inst
                                                                     -5
                                                                     "k!1")
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (typepred
                                                                         "M_xh")
                                                                        (("1"
                                                                          (inst
                                                                           -3
                                                                           "k!1+1")
                                                                          (("1"
                                                                            (lemma
                                                                             "parts_order")
                                                                            (("1"
                                                                              (inst-cp
                                                                               -1
                                                                               "a!1"
                                                                               "b!1"
                                                                               "P!1"
                                                                               "M_xl"
                                                                               "k!1+1")
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (inst-cp
                                                                                   -1
                                                                                   "a!1"
                                                                                   "b!1"
                                                                                   "P!1"
                                                                                   "M_xh"
                                                                                   "k!1")
                                                                                  (("1"
                                                                                    (inst-cp
                                                                                     -1
                                                                                     "a!1"
                                                                                     "b!1"
                                                                                     "P!1"
                                                                                     "M_xh"
                                                                                     "k!1+1")
                                                                                    (("1"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (expand "nonempty?")
                                                  (("2"
                                                    (expand "empty?")
                                                    (("2"
                                                      (expand "member")
                                                      (("2"
                                                        (inst -1 "N-1")
                                                        (("2"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (expand "nonempty?")
                                                (("2"
                                                  (expand "empty?")
                                                  (("2"
                                                    (expand "member")
                                                    (("2"
                                                      (inst -1 "k!1")
                                                      (("2"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("3"
                                                (skosimp*)
                                                (("3"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil)
                                             ("3"
                                              (skosimp*)
                                              (("3" (assertnil nil))
                                              nil)
                                             ("4"
                                              (skosimp*)
                                              (("4" (assertnil nil))
                                              nil)
                                             ("5"
                                              (skosimp*)
                                              (("5" (assertnil nil))
                                              nil)
                                             ("6"
                                              (skosimp*)
                                              (("6" (assertnil nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (lemma "triangle")
                                          (("2"
                                            (inst
                                             -1
                                             "-1 * Rie_sum(a!1, b!1, P!1, xis!1, f!1)"
                                             "xh!1-xl!1")
                                            (("2"
                                              (case
                                               "abs(xh!1 - xl!1) < epsi!1/2")
                                              (("1"
                                                (case
                                                 "abs(-1 * Rie_sum(a!1, b!1, P!1, xis!1, f!1)) < epsi!1/2")
                                                (("1" (assertnil nil)
                                                 ("2"
                                                  (hide 3)
                                                  (("2"
                                                    (rewrite
                                                     "abs_mult")
                                                    (("2"
                                                      (case-replace
                                                       "abs(-1) = 1")
                                                      (("1"
                                                        (hide -1 -2 -3)
                                                        (("1"
                                                          (lemma
                                                           "Rie_sum_alt_lem")
                                                          (("1"
                                                            (inst
                                                             -
                                                             "a!1"
                                                             "b!1"
                                                             "f!1")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (inst?)
                                                                (("1"
                                                                  (replace
                                                                   -1)
                                                                  (("1"
                                                                    (hide
                                                                     -1)
                                                                    (("1"
                                                                      (expand
                                                                       "Rie_sum_alt")
                                                                      (("1"
                                                                        (name
                                                                         "M_xh"
                                                                         "min_nat.min({j: below(N) | seq(P!1)(j) >= xh!1})")
                                                                        (("1"
                                                                          (case
                                                                           "M_xh > 1")
                                                                          (("1"
                                                                            (inst
                                                                             +
                                                                             "M_xh-2")
                                                                            (("1"
                                                                              (assert)
                                                                              (("1"
                                                                                (typepred
                                                                                 "M_xh")
                                                                                (("1"
                                                                                  (inst
                                                                                   -
                                                                                   "M_xh-1")
                                                                                  (("1"
                                                                                    (assert)
                                                                                    (("1"
                                                                                      (lemma
                                                                                       "sigma_split_ge[length(P!1) - 1]")
                                                                                      (("1"
                                                                                        (inst
                                                                                         -1
                                                                                         "_"
                                                                                         "N-1"
                                                                                         "1"
                                                                                         "M_xh-2")
                                                                                        (("1"
                                                                                          (inst
                                                                                           -
                                                                                           "(LAMBDA (n: upto(length(P!1) - 1)):
                                                                                                                                                                                                                                                                                                            Rie_sec(a!1, b!1, P!1, xis!1, f!1, n))")
                                                                                          (("1"
                                                                                            (assert)
                                                                                            (("1"
                                                                                              (replace
                                                                                               -6)
                                                                                              (("1"
                                                                                                (replace
                                                                                                 -1)
                                                                                                (("1"
                                                                                                  (hide
                                                                                                   -1)
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    (("1"
                                                                                                      (case-replace
                                                                                                       "sigma(1, M_xh - 2,
                                                                                                                                                                                                                                                                                                           (LAMBDA (n: upto(length(P!1) - 1)):
                                                                                                                                                                                                                                                                                                              Rie_sec(a!1, b!1, P!1, xis!1, f!1, n))) = 0")
                                                                                                      (("1"
                                                                                                        (assert)
                                                                                                        (("1"
                                                                                                          (case
                                                                                                           "abs(Rie_sec(a!1, b!1, P!1, xis!1, f!1, M_xh)) < epsi!1 / 4")
                                                                                                          (("1"
                                                                                                            (case
                                                                                                             "abs(Rie_sec(a!1, b!1, P!1, xis!1, f!1, M_xh-1)) < epsi!1 / 4")
                                                                                                            (("1"
                                                                                                              (lemma
                                                                                                               "sigma_first_ge[length(P!1) - 1]")
                                                                                                              (("1"
                                                                                                                (inst
                                                                                                                 -
                                                                                                                 "(LAMBDA (n: upto(length(P!1) - 1)):
                                                                                                                                                                                                                                                                                                                                                                                                              Rie_sec(a!1, b!1, P!1, xis!1, f!1, n))"
                                                                                                                 "N-1"
                                                                                                                 "M_xh-1")
                                                                                                                (("1"
                                                                                                                  (assert)
                                                                                                                  (("1"
                                                                                                                    (replace
                                                                                                                     -1)
                                                                                                                    (("1"
                                                                                                                      (hide
                                                                                                                       -1)
                                                                                                                      (("1"
                                                                                                                        (case
                                                                                                                         "1 + M_xh <= length(P!1) - 1")
                                                                                                                        (("1"
                                                                                                                          (lemma
                                                                                                                           "sigma_first_ge[length(P!1) - 1]")
                                                                                                                          (("1"
                                                                                                                            (inst
                                                                                                                             -
                                                                                                                             "(LAMBDA (n: upto(length(P!1) - 1)):
                                                                                                                                                                                                                                                                                                                                                                                                                            Rie_sec(a!1, b!1, P!1, xis!1, f!1, n))"
                                                                                                                             "N-1"
                                                                                                                             "M_xh")
                                                                                                                            (("1"
                                                                                                                              (assert)
                                                                                                                              (("1"
                                                                                                                                (replace
                                                                                                                                 -1)
                                                                                                                                (("1"
                                                                                                                                  (hide
                                                                                                                                   -1)
                                                                                                                                  (("1"
                                                                                                                                    (case-replace
                                                                                                                                     "sigma(1 + M_xh, N - 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                               (LAMBDA (n: upto(length(P!1) - 1)):
                                                                                                                                                                                                                                                                                                                                                                                                                                                  Rie_sec(a!1, b!1, P!1, xis!1, f!1, n))) = 0")
                                                                                                                                    (("1"
                                                                                                                                      (assert)
                                                                                                                                      (("1"
                                                                                                                                        (assert)
                                                                                                                                        (("1"
                                                                                                                                          (lemma
                                                                                                                                           "triangle")
                                                                                                                                          (("1"
                                                                                                                                            (inst
                                                                                                                                             -1
                                                                                                                                             "Rie_sec(a!1, b!1, P!1, xis!1, f!1, M_xh)"
                                                                                                                                             "Rie_sec(a!1, b!1, P!1, xis!1, f!1, M_xh - 1)")
                                                                                                                                            (("1"
                                                                                                                                              (assert)
                                                                                                                                              nil
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil)
                                                                                                                                     ("2"
                                                                                                                                      (hide
                                                                                                                                       3)
                                                                                                                                      (("2"
                                                                                                                                        (case-replace
                                                                                                                                         "sigma(1 + M_xh, N - 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                     (LAMBDA (n: upto(length(P!1) - 1)):
                                                                                                                                                                                                                                                                                                                                                                                                                                                        Rie_sec(a!1, b!1, P!1, xis!1, f!1, n)))
                                                                                                                                                                                                                                                                                                                                                                                                                                                = sigma(1+M_xh,N-1
                                                                                                                                                                                                                                                                                                                                                                                                                                                 , (LAMBDA (n: upto(length(P!1) - 1)): 0))")
                                                                                                                                        (("1"
                                                                                                                                          (rewrite
                                                                                                                                           "sigma_const")
                                                                                                                                          (("1"
                                                                                                                                            (skosimp*)
                                                                                                                                            (("1"
                                                                                                                                              (assert)
                                                                                                                                              nil
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil)
                                                                                                                                         ("2"
                                                                                                                                          (hide
                                                                                                                                           2)
                                                                                                                                          (("2"
                                                                                                                                            (rewrite
                                                                                                                                             "sigma_restrict_eq")
                                                                                                                                            (("1"
                                                                                                                                              (hide
                                                                                                                                               2)
                                                                                                                                              (("1"
                                                                                                                                                (expand
                                                                                                                                                 "restrict")
                                                                                                                                                (("1"
                                                                                                                                                  (apply-extensionality
                                                                                                                                                   1
                                                                                                                                                   :hide?
                                                                                                                                                   t)
                                                                                                                                                  (("1"
                                                                                                                                                    (lift-if)
                                                                                                                                                    (("1"
                                                                                                                                                      (ground)
                                                                                                                                                      (("1"
                                                                                                                                                        (expand
                                                                                                                                                         "Rie_sec")
                                                                                                                                                        (("1"
                                                                                                                                                          (assert)
                                                                                                                                                          (("1"
                                                                                                                                                            (inst
                                                                                                                                                             -
                                                                                                                                                             "xis!1(x!1-1)")
                                                                                                                                                            (("1"
                                                                                                                                                              (assert)
                                                                                                                                                              (("1"
                                                                                                                                                                (case
                                                                                                                                                                 "xis!1(x!1-1) >= xh!1")
                                                                                                                                                                (("1"
                                                                                                                                                                  (assert)
                                                                                                                                                                  nil
                                                                                                                                                                  nil)
                                                                                                                                                                 ("2"
                                                                                                                                                                  (hide
                                                                                                                                                                   -6)
                                                                                                                                                                  (("2"
                                                                                                                                                                    (typepred
                                                                                                                                                                     "xis!1(x!1-1)")
                                                                                                                                                                    (("2"
                                                                                                                                                                      (lemma
                                                                                                                                                                       "parts_order")
                                                                                                                                                                      (("2"
                                                                                                                                                                        (inst
                                                                                                                                                                         -1
                                                                                                                                                                         "a!1"
                                                                                                                                                                         "b!1"
                                                                                                                                                                         "P!1"
                                                                                                                                                                         "M_xh"
                                                                                                                                                                         "x!1-1")
                                                                                                                                                                        (("2"
                                                                                                                                                                          (assert)
                                                                                                                                                                          (("2"
                                                                                                                                                                            (lemma
                                                                                                                                                                             "xis_lem")
                                                                                                                                                                            (("2"
                                                                                                                                                                              (assert)
                                                                                                                                                                              (("2"
                                                                                                                                                                                (inst?)
                                                                                                                                                                                (("2"
                                                                                                                                                                                  (flatten)
                                                                                                                                                                                  (("2"
                                                                                                                                                                                    (assert)
                                                                                                                                                                                    nil
                                                                                                                                                                                    nil))
                                                                                                                                                                                  nil))
                                                                                                                                                                                nil))
                                                                                                                                                                              nil))
                                                                                                                                                                            nil))
                                                                                                                                                                          nil))
                                                                                                                                                                        nil))
                                                                                                                                                                      nil))
                                                                                                                                                                    nil))
                                                                                                                                                                  nil))
                                                                                                                                                                nil))
                                                                                                                                                              nil))
                                                                                                                                                            nil))
                                                                                                                                                          nil))
                                                                                                                                                        nil))
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil)
                                                                                                                                             ("2"
                                                                                                                                              (skosimp*)
                                                                                                                                              (("2"
                                                                                                                                                (assert)
                                                                                                                                                nil
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil)
                                                                                                                                         ("3"
                                                                                                                                          (skosimp*)
                                                                                                                                          (("3"
                                                                                                                                            (assert)
                                                                                                                                            nil
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil)
                                                                                                                                     ("3"
                                                                                                                                      (skosimp*)
                                                                                                                                      (("3"
                                                                                                                                        (assert)
                                                                                                                                        nil
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil)
                                                                                                                         ("2"
                                                                                                                          (typepred
                                                                                                                           "M_xh")
                                                                                                                          (("2"
                                                                                                                            (expand
                                                                                                                             "sigma"
                                                                                                                             3)
                                                                                                                            (("2"
                                                                                                                              (assert)
                                                                                                                              (("2"
                                                                                                                                (assert)
                                                                                                                                (("2"
                                                                                                                                  (lemma
                                                                                                                                   "triangle")
                                                                                                                                  (("2"
                                                                                                                                    (inst
                                                                                                                                     -1
                                                                                                                                     "Rie_sec(a!1, b!1, P!1, xis!1, f!1, M_xh)"
                                                                                                                                     "Rie_sec(a!1, b!1, P!1, xis!1, f!1, M_xh - 1)")
                                                                                                                                    (("2"
                                                                                                                                      (assert)
                                                                                                                                      nil
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil)
                                                                                                             ("2"
                                                                                                              (hide
                                                                                                               3)
                                                                                                              (("2"
                                                                                                                (lemma
                                                                                                                 "EXse")
                                                                                                                (("2"
                                                                                                                  (inst
                                                                                                                   -
                                                                                                                   "epsi!1/1000"
                                                                                                                   "a!1"
                                                                                                                   "b!1"
                                                                                                                   "f!1"
                                                                                                                   "M_xh-1"
                                                                                                                   "xh!1"
                                                                                                                   "xl!1")
                                                                                                                  (("2"
                                                                                                                    (assert)
                                                                                                                    (("2"
                                                                                                                      (inst?)
                                                                                                                      (("2"
                                                                                                                        (assert)
                                                                                                                        nil
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil)
                                                                                                           ("2"
                                                                                                            (hide
                                                                                                             3)
                                                                                                            (("2"
                                                                                                              (expand
                                                                                                               "Rie_sec")
                                                                                                              (("2"
                                                                                                                (hide
                                                                                                                 -1)
                                                                                                                (("2"
                                                                                                                  (assert)
                                                                                                                  (("2"
                                                                                                                    (case
                                                                                                                     "f!1(xis!1(M_xh - 1)) <= 1")
                                                                                                                    (("1"
                                                                                                                      (case
                                                                                                                       "P!1`seq(1 + (M_xh - 1)) - P!1`seq(M_xh - 1) < epsi!1 / 4")
                                                                                                                      (("1"
                                                                                                                        (mult-ineq
                                                                                                                         -1
                                                                                                                         -2)
                                                                                                                        (("1"
                                                                                                                          (case-replace
                                                                                                                           "f!1(xis!1(M_xh - 1)) >= 0")
                                                                                                                          (("1"
                                                                                                                            (hide-all-but
                                                                                                                             (-1
                                                                                                                              -2
                                                                                                                              1))
                                                                                                                            (("1"
                                                                                                                              (expand
                                                                                                                               "abs")
                                                                                                                              (("1"
                                                                                                                                (lift-if)
                                                                                                                                (("1"
                                                                                                                                  (case
                                                                                                                                   "seq(P!1)(M_xh) - seq(P!1)(M_xh - 1) > 0")
                                                                                                                                  (("1"
                                                                                                                                    (assert)
                                                                                                                                    (("1"
                                                                                                                                      (case
                                                                                                                                       "(seq(P!1)(M_xh) - seq(P!1)(M_xh - 1))* f!1(xis!1(M_xh - 1)) >= 0")
                                                                                                                                      (("1"
                                                                                                                                        (assert)
                                                                                                                                        nil
                                                                                                                                        nil)
                                                                                                                                       ("2"
                                                                                                                                        (hide
                                                                                                                                         -3
                                                                                                                                         2)
                                                                                                                                        (("2"
                                                                                                                                          (lemma
                                                                                                                                           "ge_times_ge_pos")
                                                                                                                                          (("2"
                                                                                                                                            (inst
                                                                                                                                             -
                                                                                                                                             "0"
                                                                                                                                             "0"
                                                                                                                                             "f!1(xis!1(M_xh - 1))"
                                                                                                                                             "seq(P!1)(M_xh) - seq(P!1)(M_xh - 1)")
                                                                                                                                            (("2"
                                                                                                                                              (assert)
                                                                                                                                              nil
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil)
                                                                                                                                   ("2"
                                                                                                                                    (hide
                                                                                                                                     2)
                                                                                                                                    (("2"
                                                                                                                                      (assert)
                                                                                                                                      nil
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil)
                                                                                                                           ("2"
                                                                                                                            (inst
                                                                                                                             -
                                                                                                                             "xis!1(M_xh - 1)")
                                                                                                                            (("2"
                                                                                                                              (assert)
                                                                                                                              nil
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil)
                                                                                                                       ("2"
                                                                                                                        (assert)
                                                                                                                        (("2"
                                                                                                                          (lemma
                                                                                                                           "width_lem")
                                                                                                                          (("2"
                                                                                                                            (assert)
                                                                                                                            (("2"
                                                                                                                              (inst
                                                                                                                               -1
                                                                                                                               "a!1"
                                                                                                                               "b!1"
                                                                                                                               "P!1"
                                                                                                                               "M_xh-1")
                                                                                                                              (("2"
                                                                                                                                (assert)
                                                                                                                                nil
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil)
                                                                                                                     ("2"
                                                                                                                      (hide
                                                                                                                       2)
                                                                                                                      (("2"
                                                                                                                        (inst
                                                                                                                         -
                                                                                                                         "xis!1(M_xh - 1)")
                                                                                                                        (("2"
                                                                                                                          (ground)
                                                                                                                          nil
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil)
                                                                                                       ("2"
                                                                                                        (hide
                                                                                                         3)
                                                                                                        (("2"
                                                                                                          (case-replace
                                                                                                           "sigma(1, M_xh - 2,
                                                                                                                                                                                                                                                                                                                                      (LAMBDA (n: upto(length(P!1) - 1)):
                                                                                                                                                                                                                                                                                                                                         Rie_sec(a!1, b!1, P!1, xis!1, f!1, n))) = sigma(1, M_xh - 2,                                                                                                                                                                      (LAMBDA (n: upto(length(P!1) - 1)):
                                                                                                                                                                                                                                                                                                                                         0))")
                                                                                                          (("1"
                                                                                                            (rewrite
                                                                                                             "sigma_const")
                                                                                                            (("1"
                                                                                                              (skosimp*)
                                                                                                              (("1"
                                                                                                                (assert)
                                                                                                                nil
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil)
                                                                                                           ("2"
                                                                                                            (hide
                                                                                                             2)
                                                                                                            (("2"
                                                                                                              (rewrite
                                                                                                               "sigma_restrict_eq")
                                                                                                              (("1"
                                                                                                                (hide
                                                                                                                 2)
                                                                                                                (("1"
                                                                                                                  (expand
                                                                                                                   "restrict")
                                                                                                                  (("1"
                                                                                                                    (apply-extensionality
                                                                                                                     1
                                                                                                                     :hide?
                                                                                                                     t)
                                                                                                                    (("1"
                                                                                                                      (lift-if)
                                                                                                                      (("1"
                                                                                                                        (ground)
                                                                                                                        (("1"
                                                                                                                          (expand
                                                                                                                           "Rie_sec")
                                                                                                                          (("1"
                                                                                                                            (case
                                                                                                                             "f!1(xis!1(x!1-1)) = 0")
                                                                                                                            (("1"
                                                                                                                              (assert)
                                                                                                                              nil
                                                                                                                              nil)
                                                                                                                             ("2"
                                                                                                                              (assert)
                                                                                                                              (("2"
                                                                                                                                (hide
                                                                                                                                 4)
                                                                                                                                (("2"
                                                                                                                                  (inst
                                                                                                                                   -
                                                                                                                                   "xis!1(x!1-1)")
                                                                                                                                  (("2"
                                                                                                                                    (assert)
                                                                                                                                    (("2"
                                                                                                                                      (ground)
                                                                                                                                      (("2"
                                                                                                                                        (lemma
                                                                                                                                         "parts_order")
                                                                                                                                        (("2"
                                                                                                                                          (inst
                                                                                                                                           -1
                                                                                                                                           "a!1"
                                                                                                                                           "b!1"
                                                                                                                                           "P!1"
                                                                                                                                           "x!1"
                                                                                                                                           "M_xh-2")
                                                                                                                                          (("2"
                                                                                                                                            (lemma
                                                                                                                                             "xis_lem")
                                                                                                                                            (("2"
                                                                                                                                              (assert)
                                                                                                                                              (("2"
                                                                                                                                                (inst?)
                                                                                                                                                (("2"
                                                                                                                                                  (flatten)
                                                                                                                                                  (("2"
                                                                                                                                                    (assert)
                                                                                                                                                    nil
                                                                                                                                                    nil))
                                                                                                                                                  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)
                                                                                                           ("3"
                                                                                                            (skosimp*)
                                                                                                            (("3"
                                                                                                              (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)
                                                                             ("2"
                                                                              (typepred
                                                                               "P!1")
                                                                              (("2"
                                                                                (inst?)
                                                                                (("2"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (assert)
                                                                            (("2"
                                                                              (case-replace
                                                                               "M_xh = 1")
                                                                              (("1"
                                                                                (replace
                                                                                 -3)
                                                                                (("1"
                                                                                  (case
                                                                                   "3 <= length(P!1)")
                                                                                  (("1"
                                                                                    (lemma
                                                                                     "sigma_first_ge[length(P!1) - 1]")
                                                                                    (("1"
                                                                                      (inst
                                                                                       -
                                                                                       "(LAMBDA (n: upto(length(P!1) - 1)): Rie_sec(a!1, b!1,
                                                                                                                 P!1, xis!1, f!1, n))"
                                                                                       "N-1"
                                                                                       "1")
                                                                                      (("1"
                                                                                        (assert)
                                                                                        (("1"
                                                                                          (replace
                                                                                           -1)
                                                                                          (("1"
                                                                                            (case-replace
                                                                                             "sigma(2, N - 1,
                                                                                                                                   (LAMBDA (n: upto(length(P!1) - 1)):
                                                                                                                                      Rie_sec(a!1, b!1, P!1, xis!1, f!1, n))) = 0")
                                                                                            (("1"
                                                                                              (hide
                                                                                               -1
                                                                                               -2)
                                                                                              (("1"
                                                                                                (lemma
                                                                                                 "EXse")
                                                                                                (("1"
                                                                                                  (inst
                                                                                                   -
                                                                                                   "epsi!1/1000"
                                                                                                   "a!1"
                                                                                                   "b!1"
                                                                                                   "f!1"
                                                                                                   "1"
                                                                                                   "xh!1"
                                                                                                   "xl!1")
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    (("1"
                                                                                                      (inst?)
                                                                                                      (("1"
                                                                                                        (assert)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil)
                                                                                             ("2"
                                                                                              (hide
                                                                                               3
                                                                                               4)
                                                                                              (("2"
                                                                                                (hide
                                                                                                 -1)
                                                                                                (("2"
                                                                                                  (case-replace
                                                                                                   "sigma(2, N - 1, (LAMBDA (n: upto(length(P!1) - 1)):
                                                                                                                               Rie_sec(a!1, b!1, P!1, xis!1, f!1, n))) = sigma(2,N-1 , (LAMBDA (n:
                                                                                                                               upto(length(P!1) - 1)): 0))")
                                                                                                  (("1"
--> --------------------

--> maximum size reached

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

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

¤ Dauer der Verarbeitung: 0.601 Sekunden  (vorverarbeitet am  2026-05-05) ¤

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