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


Quelle  rs_integral_cont.prf

  Sprache: Lisp
 

(rs_integral_cont
 (IMP_rs_integral_prep_TCC1 0
  (IMP_rs_integral_prep_TCC1-1 nil 3494863474
   ("" (lemma "connected_domain") (("" (propax) nil nil)) nil)
   ((connected_domain formula-decl nil rs_integral_cont nil)) nil))
 (IMP_rs_integral_prep_TCC2 0
  (IMP_rs_integral_prep_TCC2-1 nil 3494863474
   ("" (lemma "not_one_element") (("" (propax) nil nil)) nil)
   ((not_one_element formula-decl nil rs_integral_cont nil)) nil))
 (RS_integrable_cont_inc_TCC1 0
  (RS_integrable_cont_inc_TCC1-1 nil 3494864317
   ("" (skeep)
    (("" (skeep) (("" (hide -) (("" (grind) nil nil)) nil)) nil)) nil)
   ((real_minus_real_is_real application-judgement "real" reals nil)
    (metric_space? const-decl "bool" metric_spaces_def nil)
    (space_triangle? const-decl "bool" metric_spaces_def nil)
    (space_symmetric? const-decl "bool" metric_spaces_def nil)
    (space_zero? const-decl "bool" metric_spaces_def nil)
    (real_dist const-decl "nnreal" real_metric_space nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (minus_odd_is_odd application-judgement "odd_int" integers 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]" rs_integral_cont nil)
    (T formal-nonempty-subtype-decl nil rs_integral_cont nil)
    (set type-eq-decl nil sets nil) (fullset const-decl "set" sets nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (minus_real_is_real application-judgement "real" reals nil))
   nil))
 (RS_integrable_cont_inc_TCC2 0
  (RS_integrable_cont_inc_TCC2-1 nil 3494864317
   ("" (skeep)
    (("" (skeep)
      (("" (hide -)
        (("" (lemma "real_metric_space") (("" (inst?) nil nil)) nil))
        nil))
      nil))
    nil)
   ((real_metric_space formula-decl nil real_metric_space nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (fullset const-decl "set" sets nil))
   nil))
 (RS_integrable_cont_inc 0
  (RS_integrable_cont_inc-1 nil 3492526014
   ("" (skolem 1 ("a" "b" "f" "gg"))
    (("" (flatten)
      (("" (assert)
        (("" (label "altb" -1)
          (("" (flatten)
            (("" (label "fcont" -2)
              (("" (label "ginc" -3)
                (("" (name "CI" "closed_intv[T](a,b)")
                  (("" (replace -1)
                    (("" (label "CIname" -1)
                      ((""
                        (case "NOT uniformly_continuous?[T,real_dist,real,real_dist](f,CI)")
                        (("1"
                          (name "ff"
                                "(LAMBDA (x:real): IF T_pred(x) THEN f(x) ELSE 0 ENDIF)")
                          (("1"
                            (lemma
                             "Heine[real,real_dist,real,real_dist]")
                            (("1"
                              (inst - "LAMBDA (x:real): a<=x AND x<=b"
                               "ff")
                              (("1"
                                (assert)
                                (("1"
                                  (split -)
                                  (("1"
                                    (hide-all-but (-1 1))
                                    (("1"
                                      (expand "uniformly_continuous?")
                                      (("1"
                                        (skosimp*)
                                        (("1"
                                          (inst - "epsilon!1")
                                          (("1"
                                            (skosimp*)
                                            (("1"
                                              (inst + "delta!1")
                                              (("1"
                                                (skosimp*)
                                                (("1"
                                                  (inst - "x!1" "p!1")
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (expand "ff")
                                                      (("1"
                                                        (propax)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (assert)
                                                    (("2"
                                                      (typepred "p!1")
                                                      (("2"
                                                        (expand "CI")
                                                        (("2"
                                                          (propax)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("3"
                                                    (typepred "x!1")
                                                    (("3"
                                                      (expand "CI")
                                                      (("3"
                                                        (propax)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (hide-all-but ("fcont" 1))
                                    (("2"
                                      (expand "continuous?")
                                      (("2"
                                        (skosimp*)
                                        (("2"
                                          (inst - "x!1")
                                          (("1"
                                            (expand "continuous_at?")
                                            (("1"
                                              (skosimp*)
                                              (("1"
                                                (inst - "epsilon!1")
                                                (("1"
                                                  (skosimp*)
                                                  (("1"
                                                    (inst + "delta!1")
                                                    (("1"
                                                      (skosimp*)
                                                      (("1"
                                                        (inst - "y!1")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (expand
                                                             "ball")
                                                            (("1"
                                                              (case
                                                               "T_pred(x!1) AND T_pred(y!1)")
                                                              (("1"
                                                                (flatten)
                                                                (("1"
                                                                  (expand
                                                                   "ff")
                                                                  (("1"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (hide-all-but
                                                                 1)
                                                                (("2"
                                                                  (lemma
                                                                   "connected_domain")
                                                                  (("2"
                                                                    (expand
                                                                     "connected?")
                                                                    (("2"
                                                                      (inst-cp
                                                                       -
                                                                       "a"
                                                                       "b"
                                                                       "x!1")
                                                                      (("2"
                                                                        (inst
                                                                         -
                                                                         "a"
                                                                         "b"
                                                                         "y!1")
                                                                        (("2"
                                                                          (assert)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (hide-all-but
                                                           1)
                                                          (("2"
                                                            (expand
                                                             "CI")
                                                            (("2"
                                                              (lemma
                                                               "connected_domain")
                                                              (("2"
                                                                (expand
                                                                 "connected?")
                                                                (("2"
                                                                  (inst
                                                                   -
                                                                   "a"
                                                                   "b"
                                                                   "y!1")
                                                                  (("2"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (hide-all-but 1)
                                            (("2"
                                              (expand "CI")
                                              (("2"
                                                (lemma
                                                 "connected_domain")
                                                (("2"
                                                  (expand "connected?")
                                                  (("2"
                                                    (inst
                                                     -
                                                     "a"
                                                     "b"
                                                     "x!1")
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("3"
                                    (lemma "closed_intervals_compact")
                                    (("3" (inst - "a" "b"nil nil))
                                    nil)
                                   ("4"
                                    (assert)
                                    (("4"
                                      (hide-all-but (-1))
                                      (("4"
                                        (expand "empty?")
                                        (("4"
                                          (inst - "a")
                                          (("4"
                                            (expand "member")
                                            (("4" (propax) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (label "funif" -1)
                          (("2" (lemma "integrable_lem2")
                            (("2" (inst - "a" "b" "f" "gg")
                              (("2"
                                (assert)
                                (("2"
                                  (split -)
                                  (("1"
                                    (hide 2)
                                    (("1"
                                      (skolem 1 "eps")
                                      (("1"
                                        (expand
                                         "uniformly_continuous?")
                                        (("1"
                                          (name
                                           "newep"
                                           "eps/(2*(abs(gg(b)-gg(a)) + 1))")
                                          (("1"
                                            (label "newepname" -1)
                                            (("1"
                                              (inst "funif" "newep")
                                              (("1"
                                                (skolem
                                                 "funif"
                                                 "deltaf")
                                                (("1"
                                                  (inst + "deltaf/2")
                                                  (("1"
                                                    (skeep)
                                                    (("1"
                                                      (label
                                                       "Pwidth"
                                                       -2)
                                                      (("1"
                                                        (skolem
                                                         1
                                                         ("RSS1"
                                                          "RSS2"))
                                                        (("1"
                                                          (typepred
                                                           "RSS1")
                                                          (("1"
                                                            (label
                                                             "RSS1name"
                                                             -1)
                                                            (("1"
                                                              (typepred
                                                               "RSS2")
                                                              (("1"
                                                                (label
                                                                 "RSS2name"
                                                                 -1)
                                                                (("1"
                                                                  (expand
                                                                   "Riemann_sum?")
                                                                  (("1"
                                                                    (skolem
                                                                     "RSS2name"
                                                                     "xis2")
                                                                    (("1"
                                                                      (skolem
                                                                       "RSS1name"
                                                                       "xis1")
                                                                      (("1"
                                                                        (replace
                                                                         "RSS1name"
                                                                         +)
                                                                        (("1"
                                                                          (replace
                                                                           "RSS2name"
                                                                           +)
                                                                          (("1"
                                                                            (expand
                                                                             "Rie_sum"
                                                                             +)
                                                                            (("1"
                                                                              (rewrite
                                                                               "sigma_minus")
                                                                              (("1"
                                                                                (lemma
                                                                                 "sigma_abs[below(P`length-1)]")
                                                                                (("1"
                                                                                  (inst?)
                                                                                  (("1"
                                                                                    (case
                                                                                     "sigma(0, P`length - 2,
                                                                                            LAMBDA (n: below(P`length - 1)):
                                                                                              abs(f(xis1`seq(n)) * gg(P`seq(1 + n)) +
                                                                                                   f(xis2`seq(n)) * gg(P`seq(n))
                                                                                                   - f(xis1`seq(n)) * gg(P`seq(n))
                                                                                                   - f(xis2`seq(n)) * gg(P`seq(1 + n)))) < eps")
                                                                                    (("1"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil)
                                                                                     ("2"
                                                                                      (hide
                                                                                       -1)
                                                                                      (("2"
                                                                                        (hide
                                                                                         2)
                                                                                        (("2"
                                                                                          (lemma
                                                                                           "sigma_le[below(P`length-1)]")
                                                                                          (("2"
                                                                                            (inst
                                                                                             -
                                                                                             "LAMBDA (n: below(P`length - 1)):
                                                                              abs(f(xis1`seq(n)) * gg(P`seq(1 + n)) +
                                                                                   f(xis2`seq(n)) * gg(P`seq(n))
                                                                                   - f(xis1`seq(n)) * gg(P`seq(n))
                                                                                   - f(xis2`seq(n)) * gg(P`seq(1 + n)))"
                                                                                             "LAMBDA (n: below(P`length - 1)):
                                                                              newep * (gg(P`seq(1 + n))- gg(P`seq(n)))"
                                                                                             "P`length-2"
                                                                                             "0")
                                                                                            (("2"
                                                                                              (assert)
                                                                                              (("2"
                                                                                                (case
                                                                                                 "sigma(0, P`length - 2,
                                                                                                       LAMBDA (n: below(P`length - 1)):
                                                                                                         gg(P`seq(1 + n)) * newep - gg(P`seq(n)) * newep) < eps")
                                                                                                (("1"
                                                                                                  (assert)
                                                                                                  (("1"
                                                                                                    (hide
                                                                                                     2)
                                                                                                    (("1"
                                                                                                      (skolem
                                                                                                       1
                                                                                                       "nn")
                                                                                                      (("1"
                                                                                                        (case
                                                                                                         "abs(f(xis1`seq(nn))-f(xis2`seq(nn)))< newep")
                                                                                                        (("1"
                                                                                                          (mult-by
                                                                                                           -1
                                                                                                           "abs(gg(P`seq(1+nn))-gg(P`seq(nn)))")
                                                                                                          (("1"
                                                                                                            (case
                                                                                                             "abs(gg(P`seq(1 + nn)) - gg(P`seq(nn))) = gg(P`seq(1 + nn)) - gg(P`seq(nn))")
                                                                                                            (("1"
                                                                                                              (rewrite
                                                                                                               "abs_mult"
                                                                                                               -2
                                                                                                               :dir
                                                                                                               rl)
                                                                                                              (("1"
                                                                                                                (assert)
                                                                                                                nil
                                                                                                                nil))
                                                                                                              nil)
                                                                                                             ("2"
                                                                                                              (hide
                                                                                                               2)
                                                                                                              (("2"
                                                                                                                (copy
                                                                                                                 "ginc")
                                                                                                                (("2"
                                                                                                                  (expand
                                                                                                                   "increasing?"
                                                                                                                   -1)
                                                                                                                  (("2"
                                                                                                                    (expand
                                                                                                                     "restrict")
                                                                                                                    (("2"
                                                                                                                      (inst
                                                                                                                       -
                                                                                                                       "P`seq(nn)"
                                                                                                                       "P`seq(1+nn)")
                                                                                                                      (("1"
                                                                                                                        (assert)
                                                                                                                        (("1"
                                                                                                                          (expand
                                                                                                                           "abs"
                                                                                                                           +)
                                                                                                                          (("1"
                                                                                                                            (lift-if)
                                                                                                                            (("1"
                                                                                                                              (ground)
                                                                                                                              (("1"
                                                                                                                                (typepred
                                                                                                                                 "P")
                                                                                                                                (("1"
                                                                                                                                  (expand
                                                                                                                                   "increasing?")
                                                                                                                                  (("1"
                                                                                                                                    (inst
                                                                                                                                     -
                                                                                                                                     "nn"
                                                                                                                                     "1+nn")
                                                                                                                                    (("1"
                                                                                                                                      (assert)
                                                                                                                                      nil
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil)
                                                                                                                       ("2"
                                                                                                                        (hide
                                                                                                                         2)
                                                                                                                        (("2"
                                                                                                                          (typepred
                                                                                                                           "P")
                                                                                                                          (("2"
                                                                                                                            (inst
                                                                                                                             -
                                                                                                                             "1+nn")
                                                                                                                            nil
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil)
                                                                                                                       ("3"
                                                                                                                        (typepred
                                                                                                                         "P")
                                                                                                                        (("3"
                                                                                                                          (inst
                                                                                                                           -
                                                                                                                           "nn")
                                                                                                                          nil
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (hide
                                                                                                           2)
                                                                                                          (("2"
                                                                                                            (inst
                                                                                                             "funif"
                                                                                                             "xis1`seq(nn)"
                                                                                                             "xis2`seq(nn)")
                                                                                                            (("1"
                                                                                                              (assert)
                                                                                                              (("1"
                                                                                                                (expand
                                                                                                                 "real_dist")
                                                                                                                (("1"
                                                                                                                  (hide-all-but
                                                                                                                   ("funif"
                                                                                                                    "Pwidth"))
                                                                                                                  (("1"
                                                                                                                    (typepred
                                                                                                                     "xis1")
                                                                                                                    (("1"
                                                                                                                      (inst
                                                                                                                       -
                                                                                                                       "nn")
                                                                                                                      (("1"
                                                                                                                        (typepred
                                                                                                                         "xis2")
                                                                                                                        (("1"
                                                                                                                          (inst
                                                                                                                           -
                                                                                                                           "nn")
                                                                                                                          (("1"
                                                                                                                            (assert)
                                                                                                                            (("1"
                                                                                                                              (flatten)
                                                                                                                              (("1"
                                                                                                                                (lemma
                                                                                                                                 "width_lem")
                                                                                                                                (("1"
                                                                                                                                  (inst
                                                                                                                                   -
                                                                                                                                   "a"
                                                                                                                                   "b"
                                                                                                                                   "P"
                                                                                                                                   "nn")
                                                                                                                                  (("1"
                                                                                                                                    (grind
                                                                                                                                     :exclude
                                                                                                                                     "width")
                                                                                                                                    nil
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil)
                                                                                                             ("2"
                                                                                                              (typepred
                                                                                                               "xis2")
                                                                                                              (("2"
                                                                                                                (inst
                                                                                                                 -
                                                                                                                 "nn")
                                                                                                                (("2"
                                                                                                                  (flatten)
                                                                                                                  (("2"
                                                                                                                    (typepred
                                                                                                                     "P")
                                                                                                                    (("2"
                                                                                                                      (inst-cp
                                                                                                                       -
                                                                                                                       "nn")
                                                                                                                      (("2"
                                                                                                                        (inst-cp
                                                                                                                         -
                                                                                                                         "nn+1")
                                                                                                                        (("2"
                                                                                                                          (ground)
                                                                                                                          (("2"
                                                                                                                            (expand
                                                                                                                             "CI")
                                                                                                                            (("2"
                                                                                                                              (propax)
                                                                                                                              nil
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil)
                                                                                                             ("3"
                                                                                                              (typepred
                                                                                                               "xis1")
                                                                                                              (("3"
                                                                                                                (inst
                                                                                                                 -
                                                                                                                 "nn")
                                                                                                                (("3"
                                                                                                                  (flatten)
                                                                                                                  (("3"
                                                                                                                    (typepred
                                                                                                                     "P")
                                                                                                                    (("3"
                                                                                                                      (inst-cp
                                                                                                                       -
                                                                                                                       "nn")
                                                                                                                      (("3"
                                                                                                                        (inst-cp
                                                                                                                         -
                                                                                                                         "nn+1")
                                                                                                                        (("3"
                                                                                                                          (ground)
                                                                                                                          (("3"
                                                                                                                            (expand
                                                                                                                             "CI")
                                                                                                                            (("3"
                                                                                                                              (propax)
                                                                                                                              nil
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil)
                                                                                                 ("2"
                                                                                                  (hide
                                                                                                   2)
                                                                                                  (("2"
                                                                                                    (case
                                                                                                     "FORALL (nn:below(P`length-1)): sigma(0, nn,
                                                                         LAMBDA (n: below(P`length - 1)):
                                                                           gg(P`seq(1 + n)) * newep - gg(P`seq(n)) * newep) = newep*(gg(P`seq(1+nn))-gg(P`seq(0)))")
                                                                                                    (("1"
                                                                                                      (inst
                                                                                                       -
                                                                                                       "P`length-2")
                                                                                                      (("1"
                                                                                                        (assert)
                                                                                                        (("1"
                                                                                                          (replace
                                                                                                           -1)
                                                                                                          (("1"
                                                                                                            (typepred
                                                                                                             "P")
                                                                                                            (("1"
                                                                                                              (replace
                                                                                                               -2)
                                                                                                              (("1"
                                                                                                                (replace
                                                                                                                 -3)
                                                                                                                (("1"
                                                                                                                  (case
                                                                                                                   "(gg(b)-gg(a))*newep < eps")
                                                                                                                  (("1"
                                                                                                                    (assert)
                                                                                                                    nil
                                                                                                                    nil)
                                                                                                                   ("2"
                                                                                                                    (name
                                                                                                                     "CC1"
                                                                                                                     "gg(b)-gg(a)")
                                                                                                                    (("2"
                                                                                                                      (replace
                                                                                                                       -1)
                                                                                                                      (("2"
                                                                                                                        (expand
                                                                                                                         "newep"
                                                                                                                         1)
                                                                                                                        (("2"
                                                                                                                          (cross-mult
                                                                                                                           1)
                                                                                                                          (("2"
                                                                                                                            (replace
                                                                                                                             -1
                                                                                                                             :dir
                                                                                                                             rl)
                                                                                                                            (("2"
                                                                                                                              (assert)
                                                                                                                              (("2"
                                                                                                                                (copy
                                                                                                                                 "ginc")
                                                                                                                                (("2"
                                                                                                                                  (expand
                                                                                                                                   "increasing?"
                                                                                                                                   -1)
                                                                                                                                  (("2"
                                                                                                                                    (expand
                                                                                                                                     "restrict")
                                                                                                                                    (("2"
                                                                                                                                      (inst
                                                                                                                                       -
                                                                                                                                       "a"
                                                                                                                                       "b")
                                                                                                                                      (("2"
                                                                                                                                        (assert)
                                                                                                                                        (("2"
                                                                                                                                          (expand
                                                                                                                                           "abs")
                                                                                                                                          (("2"
                                                                                                                                            (assert)
                                                                                                                                            nil
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (hide
                                                                                                       2)
                                                                                                      (("2"
                                                                                                        (induct
                                                                                                         "nn")
                                                                                                        (("1"
                                                                                                          (hide
                                                                                                           -1)
                                                                                                          (("1"
                                                                                                            (assert)
                                                                                                            (("1"
                                                                                                              (expand
                                                                                                               "sigma")
                                                                                                              (("1"
                                                                                                                (expand
                                                                                                                 "sigma")
                                                                                                                (("1"
                                                                                                                  (propax)
                                                                                                                  nil
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (skolem
                                                                                                           1
                                                                                                           "nn")
                                                                                                          (("2"
                                                                                                            (hide
                                                                                                             -1)
                                                                                                            (("2"
                                                                                                              (assert)
                                                                                                              (("2"
                                                                                                                (flatten)
                                                                                                                (("2"
                                                                                                                  (expand
                                                                                                                   "sigma"
                                                                                                                   +)
                                                                                                                  (("2"
                                                                                                                    (replace
                                                                                                                     -2)
                                                                                                                    (("2"
                                                                                                                      (assert)
                                                                                                                      nil
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil)
                                                                                                         ("3"
                                                                                                          (hide
                                                                                                           -1)
                                                                                                          (("3"
                                                                                                            (hide
                                                                                                             2)
                                                                                                            (("3"
                                                                                                              (skosimp*)
                                                                                                              (("3"
                                                                                                                (assert)
                                                                                                                nil
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil)
                                                                                                         ("4"
                                                                                                          (hide
                                                                                                           1)
                                                                                                          (("4"
                                                                                                            (hide
                                                                                                             2)
                                                                                                            (("4"
                                                                                                              (skosimp*)
                                                                                                              (("4"
                                                                                                                (assert)
                                                                                                                nil
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("3"
                                                                                                      (hide
                                                                                                       (-1
                                                                                                        2))
                                                                                                      (("3"
                                                                                                        (skosimp*)
                                                                                                        (("3"
                                                                                                          (assert)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (hide
                                                                                   2)
                                                                                  (("2"
                                                                                    (skosimp*)
                                                                                    (("2"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (hide
                                                                                 2)
                                                                                (("2"
                                                                                  (skosimp*)
                                                                                  (("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)
                                   ("2"
                                    (expand "monotonic?")
                                    (("2" (propax) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("3" (lemma "real_metric_space")
                          (("3" (inst?) nil nil)) nil)
                         ("4" (hide-all-but 1) (("4" (grind) nil nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (T formal-nonempty-subtype-decl nil rs_integral_cont nil)
    (T_pred const-decl "[real -> boolean]" rs_integral_cont nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (space_triangle? const-decl "bool" metric_spaces_def nil)
    (space_symmetric? const-decl "bool" metric_spaces_def nil)
    (space_zero? const-decl "bool" metric_spaces_def nil)
    (real_metric_space formula-decl nil real_metric_space nil)
    (posreal_times_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (posreal_div_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (/= const-decl "boolean" notequal nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (barray type-eq-decl nil fseqs "structures/")
    (fseq type-eq-decl nil fseqs "structures/")
    (increasing? const-decl "bool" sort_fseq "structures/")
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (below type-eq-decl nil naturalnumbers nil)
    (partition type-eq-decl nil rs_partition nil)
    (Riemann_sum? const-decl "bool" rs_integral_def nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (integer nonempty-type-from-decl nil integers nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (T_low type-eq-decl nil sigma "reals/")
    (T_high type-eq-decl nil sigma "reals/")
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (xis? type-eq-decl nil rs_integral_def nil)
    (sigma_minus formula-decl nil sigma "reals/")
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nnreal_plus_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (nnreal_times_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (posreal_plus_nnreal_is_posreal application-judgement "posreal"
     real_types nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (sigma_le formula-decl nil sigma "reals/")
    (below_induction formula-decl nil bounded_nat_inductions nil)
    (pred type-eq-decl nil defined_types nil)
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (times_div1 formula-decl nil real_props nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (div_mult_pos_lt1 formula-decl nil real_props nil)
    (newep skolem-const-decl "posreal" rs_integral_cont nil)
    (width_lem formula-decl nil rs_partition nil)
    (xis2 skolem-const-decl "xis?[T](a, b, P)" rs_integral_cont nil)
    (xis1 skolem-const-decl "xis?[T](a, b, P)" rs_integral_cont nil)
    (both_sides_times_pos_lt1 formula-decl nil real_props nil)
    (nn skolem-const-decl "subrange(0, P`length - 2)" rs_integral_cont
     nil)
    (P skolem-const-decl "partition[T](a, b)" rs_integral_cont nil)
    (gg skolem-const-decl "[T -> real]" rs_integral_cont nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (abs_nat formula-decl nil abs_lems "reals/")
    (increasing? const-decl "bool" real_fun_preds "reals/")
    (minus_real_is_real application-judgement "real" reals nil)
    (abs_mult formula-decl nil real_props nil)
    (subrange type-eq-decl nil integers nil)
    (sigma_nnreal application-judgement "nnreal" sigma_below "reals/")
    (sigma def-decl "real" sigma "reals/")
    (sigma_abs formula-decl nil sigma "reals/")
    (Rie_sum const-decl "real" rs_integral_def nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (monotonic? const-decl "bool" real_fun_preds "reals/")
    (integrable_lem2 formula-decl nil rs_integral_prep nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (a skolem-const-decl "T" rs_integral_cont nil)
    (CI skolem-const-decl "[T -> bool]" rs_integral_cont nil)
    (x!1 skolem-const-decl "(CI)" rs_integral_cont nil)
    (b skolem-const-decl "T" rs_integral_cont nil)
    (p!1 skolem-const-decl "(CI)" rs_integral_cont nil)
    (ff skolem-const-decl "[real -> real]" rs_integral_cont nil)
    (continuous? const-decl "bool" continuity_ms_def nil)
    (x!1 skolem-const-decl "(LAMBDA (x: real): a <= x AND x <= b)"
     rs_integral_cont nil)
    (member const-decl "bool" sets nil)
    (connected_domain formula-decl nil rs_integral_cont nil)
    (connected? const-decl "bool" deriv_domain_def nil)
    (ball const-decl "set[T]" metric_spaces nil)
    (y!1 skolem-const-decl "(LAMBDA (x: real): a <= x AND x <= b)"
     rs_integral_cont nil)
    (continuous_at? const-decl "bool" continuity_ms_def nil)
    (< const-decl "bool" reals nil)
    (closed_intervals_compact formula-decl nil real_metric_space nil)
    (empty? const-decl "bool" sets nil)
    (Heine formula-decl nil uniform_continuity nil)
    (metric_space? const-decl "bool" metric_spaces_def nil)
    (fullset const-decl "set" sets nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (set type-eq-decl nil sets nil) (>= const-decl "bool" reals nil)
    (nnreal type-eq-decl nil real_types nil)
    (restrict const-decl "R" restrict nil)
    (real_dist const-decl "nnreal" real_metric_space nil)
    (uniformly_continuous? const-decl "bool" uniform_continuity nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   nil))
 (RS_integrable_cont_BV 0
  (RS_integrable_cont_BV-1 nil 3492526083
   ("" (skolem 1 ("a" "b" "f" "gg"))
    (("" (assert)
      (("" (flatten)
        (("" (lemma "BV_decomposition")
          (("" (inst - "a" "b" "gg")
            (("" (assert)
              (("" (skolem -1 ("vv" "ww"))
                (("" (flatten)
                  (("" (lemma "RS_integrable_cont_inc")
                    (("" (inst-cp - "a" "b" "f" "vv")
                      (("" (inst - "a" "b" "f" "ww")
                        (("" (assert)
                          (("" (replace -3)
                            (("" (lemma "integral_diff_g")
                              ((""
                                (inst - "a" "b" "f" "vv" "ww")
                                (("" (assertnil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (T formal-nonempty-subtype-decl nil rs_integral_cont nil)
    (T_pred const-decl "[real -> boolean]" rs_integral_cont 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)
    (BV_decomposition formula-decl nil bounded_variation nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (integral_diff_g formula-decl nil rs_integral_prep nil)
    (RS_integrable_cont_inc formula-decl nil rs_integral_cont nil))
   shostak)))


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

¤ Dauer der Verarbeitung: 0.43 Sekunden  (vorverarbeitet am  2026-04-28) ¤

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