Gedichte Musik Bilder Quellcodebibliothek Diashow Normaldarstellung
products/Sources/formale Sprachen/PVS/exact_real_arith/  image not shown  

Quellcode-Bibliothek

© Kompilation durch diese Firma

[Weder Korrektheit noch Funktionsfähigkeit der Software werden zugesichert.]

Datei: exp.prf   Sprache: Lisp

Original von: PVS©
(exp (cauchy_exp_series_TCC1 0
      (cauchy_exp_series_TCC1-1 nil 3394181533
       ("" (skosimp*)
        (("" (expand "cauchy_nzreal?")
          (("" (inst + "factorial(n!1)")
            (("" (rewrite "int_lemma") nil nil)) nil))
          nil))
        nil)
       ((cauchy_nzreal? const-decl "bool" cauchy nil)
        (int_lemma formula-decl nil int nil)
        (factorial def-decl "posnat" factorial "ints/")
        (posnat nonempty-type-eq-decl nil integers nil)
        (> const-decl "bool" reals nil)
        (nonneg_int nonempty-type-eq-decl nil integers nil)
        (nat nonempty-type-eq-decl nil naturalnumbers nil)
        (>= const-decl "bool" reals nil)
        (bool nonempty-type-eq-decl nil booleans nil)
        (int nonempty-type-eq-decl nil integers nil)
        (integer_pred const-decl "[rational -> boolean]" integers nil)
        (rational nonempty-type-from-decl nil rationals nil)
        (rational_pred const-decl "[real -> boolean]" rationals nil)
        (nzreal nonempty-type-eq-decl nil reals nil)
        (/= const-decl "boolean" notequal nil)
        (real nonempty-type-from-decl nil reals nil)
        (real_pred const-decl "[number_field -> boolean]" reals nil)
        (number_field nonempty-type-from-decl nil number_fields nil)
        (number_field_pred const-decl "[number -> boolean]"
         number_fields nil)
        (boolean nonempty-type-decl nil booleans nil)
        (number nonempty-type-decl nil numbers nil))
       nil))
     (cauchy_exp_series_TCC2 0
      (cauchy_exp_series_TCC2-1 nil 3394181533
       ("" (skosimp*)
        ((""
          (lemma "inv_lemma"
           ("nzx" "factorial(n!1)" "nzcx"
            "cauchy_int(factorial(n!1))"))
          (("" (rewrite "int_lemma")
            (("" (expand "cauchy_nnreal?")
              (("" (inst + "1 / factorial(n!1)") nil nil)) nil))
            nil))
          nil))
        nil)
       ((nzreal nonempty-type-eq-decl nil reals nil)
        (/= const-decl "boolean" notequal nil)
        (factorial def-decl "posnat" factorial "ints/")
        (posnat nonempty-type-eq-decl nil integers nil)
        (> const-decl "bool" reals nil)
        (nonneg_int nonempty-type-eq-decl nil integers nil)
        (cauchy_int const-decl "cauchy_real" int nil)
        (cauchy_real nonempty-type-eq-decl nil cauchy nil)
        (cauchy_real? const-decl "bool" cauchy nil)
        (cauchy_nzreal nonempty-type-eq-decl nil cauchy nil)
        (cauchy_nzreal? const-decl "bool" cauchy nil)
        (nat nonempty-type-eq-decl nil naturalnumbers nil)
        (>= const-decl "bool" reals nil)
        (bool nonempty-type-eq-decl nil booleans nil)
        (int nonempty-type-eq-decl nil integers nil)
        (integer_pred const-decl "[rational -> boolean]" integers nil)
        (rational nonempty-type-from-decl nil rationals nil)
        (rational_pred const-decl "[real -> boolean]" rationals nil)
        (real nonempty-type-from-decl nil reals nil)
        (real_pred const-decl "[number_field -> boolean]" reals nil)
        (number_field nonempty-type-from-decl nil number_fields nil)
        (number_field_pred const-decl "[number -> boolean]"
         number_fields nil)
        (boolean nonempty-type-decl nil booleans nil)
        (number nonempty-type-decl nil numbers nil)
        (inv_lemma formula-decl nil inv nil)
        (cauchy_nnreal? const-decl "bool" cauchy nil)
        (nnreal type-eq-decl nil real_types nil)
        (numfield nonempty-type-eq-decl nil number_fields nil)
        (nznum nonempty-type-eq-decl nil number_fields nil)
        (/ const-decl "[numfield, nznum -> numfield]" number_fields
           nil)
        (posrat_div_posrat_is_posrat application-judgement "posrat"
         rationals nil)
        (int_lemma formula-decl nil int nil))
       nil))
     (exp_series_lemma 0
      (exp_series_lemma-1 nil 3394181733
       ("" (skosimp)
        (("" (expand "cauchy_exp_series")
          (("" (expand "expT")
            (("" (case-replace "n!1=0")
              (("1" (expand "factorial")
                (("1"
                  (lemma "inv_lemma"
                   ("nzx" "1" "nzcx" "cauchy_int(1)"))
                  (("1" (rewrite "int_lemma") (("1" (assert) nil nil))
                    nil))
                  nil))
                nil)
               ("2" (assert)
                (("2" (rewrite "expt_1i")
                  (("2"
                    (lemma "inv_lemma"
                     ("nzx" "factorial(n!1)" "nzcx"
                      "cauchy_int(factorial(n!1))"))
                    (("2" (rewrite "int_lemma") nil nil)) nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ((cauchy_exp_series const-decl "cauchy_nnreal" exp nil)
        (number nonempty-type-decl nil numbers nil)
        (boolean nonempty-type-decl nil booleans nil)
        (= const-decl "[T, T -> boolean]" equalities nil)
        (number_field_pred const-decl "[number -> boolean]"
         number_fields nil)
        (number_field nonempty-type-from-decl nil number_fields nil)
        (real_pred const-decl "[number_field -> boolean]" reals nil)
        (real nonempty-type-from-decl nil reals nil)
        (rational_pred const-decl "[real -> boolean]" rationals nil)
        (rational nonempty-type-from-decl nil rationals nil)
        (integer_pred const-decl "[rational -> boolean]" integers nil)
        (int nonempty-type-eq-decl nil integers nil)
        (bool nonempty-type-eq-decl nil booleans nil)
        (>= const-decl "bool" reals nil)
        (nat nonempty-type-eq-decl nil naturalnumbers nil)
        (nzreal nonempty-type-eq-decl nil reals nil)
        (/= const-decl "boolean" notequal nil)
        (cauchy_int const-decl "cauchy_real" int nil)
        (cauchy_real nonempty-type-eq-decl nil cauchy nil)
        (cauchy_real? const-decl "bool" cauchy nil)
        (cauchy_nzreal nonempty-type-eq-decl nil cauchy nil)
        (cauchy_nzreal? const-decl "bool" cauchy nil)
        (inv_lemma formula-decl nil inv nil)
        (int_lemma formula-decl nil int nil)
        (factorial def-decl "posnat" factorial "ints/")
        (posnat nonempty-type-eq-decl nil integers nil)
        (> const-decl "bool" reals nil)
        (nonneg_int nonempty-type-eq-decl nil integers nil)
        (expt_1i formula-decl nil exponentiation nil)
        (posrat_div_posrat_is_posrat application-judgement "posrat"
         rationals nil)
        (posint_exp application-judgement "posint" exponentiation nil)
        (expT const-decl "real" ln_exp_series_alt "lnexp_fnd/"))
       shostak))
     (exp_estimate_lemma_TCC1 0
      (exp_estimate_lemma_TCC1-1 nil 3394181533
       ("" (skosimp)
        (("" (expand "cauchys_real?")
          (("" (lemma "exp_series_lemma")
            (("" (inst + "expT(1)")
              (("" (expand "cauchys_prop") (("" (propax) nil nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ((cauchys_real? const-decl "bool" sum nil)
        (number nonempty-type-decl nil numbers nil)
        (boolean nonempty-type-decl nil booleans nil)
        (number_field_pred const-decl "[number -> boolean]"
         number_fields nil)
        (number_field nonempty-type-from-decl nil number_fields nil)
        (real_pred const-decl "[number_field -> boolean]" reals nil)
        (real nonempty-type-from-decl nil reals nil)
        (rational_pred const-decl "[real -> boolean]" rationals nil)
        (rational nonempty-type-from-decl nil rationals nil)
        (integer_pred const-decl "[rational -> boolean]" integers nil)
        (int nonempty-type-eq-decl nil integers nil)
        (bool nonempty-type-eq-decl nil booleans nil)
        (>= const-decl "bool" reals nil)
        (nat nonempty-type-eq-decl nil naturalnumbers nil)
        (expT const-decl "real" ln_exp_series_alt "lnexp_fnd/")
        (cauchys_prop const-decl "bool" sum nil)
        (exp_series_lemma formula-decl nil exp nil))
       nil))
     (exp_estimate_lemma 0
      (exp_estimate_lemma-1 nil 3394181952
       ("" (skosimp)
        (("" (expand "exp_estimate")
          ((""
            (lemma "powerseries_lemma"
             ("x" "x!1" "xs" "expT(1)" "cx" "cx!1" "cxs"
              "cauchy_exp_series" "m" "n!1"))
            (("" (replace -2)
              (("" (lemma "exp_series_lemma")
                (("" (replace -1)
                  (("" (expand "powerseries")
                    ((""
                      (case-replace "(LAMBDA (i:nat):
                          IF i = 0 THEN expT(1)(i)
                          ELSE expT(1)(i) * x!1 ^ i
                          ENDIF)=expT(x!1)")
                      (("" (hide-all-but 1)
                        (("" (apply-extensionality :hide? t)
                          (("" (expand "expT")
                            (("" (case-replace "x!2=0")
                              ((""
                                (assert)
                                ((""
                                  (rewrite "expt_1i")
                                  (("" (assert) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ((exp_estimate const-decl "real" ln_exp_series_alt "lnexp_fnd/")
        (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
        (NOT const-decl "[bool -> bool]" booleans nil)
        (^ const-decl "real" exponentiation nil)
        (/= const-decl "boolean" notequal nil)
        (OR const-decl "[bool, bool -> bool]" booleans nil)
        (* const-decl "[numfield, numfield -> numfield]" number_fields
           nil)
        (IF const-decl "[boolean, T, T -> T]" if_def nil)
        (= const-decl "[T, T -> boolean]" equalities nil)
        (numfield nonempty-type-eq-decl nil number_fields nil)
        (real_times_real_is_real application-judgement "real" reals
         nil)
        (posrat_div_posrat_is_posrat application-judgement "posrat"
         rationals nil)
        (posint_exp application-judgement "posint" exponentiation nil)
        (real_div_nzreal_is_real application-judgement "real" reals
         nil)
        (expt_1i formula-decl nil exponentiation nil)
        (powerseries const-decl "real" powerseries nil)
        (exp_series_lemma formula-decl nil exp nil)
        (powerseries_lemma formula-decl nil powerseries nil)
        (number nonempty-type-decl nil numbers nil)
        (boolean nonempty-type-decl nil booleans nil)
        (number_field_pred const-decl "[number -> boolean]"
         number_fields nil)
        (number_field nonempty-type-from-decl nil number_fields nil)
        (real_pred const-decl "[number_field -> boolean]" reals nil)
        (real nonempty-type-from-decl nil reals nil)
        (rational_pred const-decl "[real -> boolean]" rationals nil)
        (rational nonempty-type-from-decl nil rationals nil)
        (integer_pred const-decl "[rational -> boolean]" integers nil)
        (int nonempty-type-eq-decl nil integers nil)
        (bool nonempty-type-eq-decl nil booleans nil)
        (>= const-decl "bool" reals nil)
        (nat nonempty-type-eq-decl nil naturalnumbers nil)
        (cauchy_real? const-decl "bool" cauchy nil)
        (cauchy_real nonempty-type-eq-decl nil cauchy nil)
        (cauchy_nnreal? const-decl "bool" cauchy nil)
        (cauchy_nnreal nonempty-type-eq-decl nil cauchy nil)
        (cauchy_exp_series const-decl "cauchy_nnreal" exp nil)
        (expT const-decl "real" ln_exp_series_alt "lnexp_fnd/"))
       shostak))
     (cauchy_exp_dr_TCC1 0
      (cauchy_exp_dr_TCC1-1 nil 3394183332
       ("" (lemma "exp_series_lemma")
        (("" (expand "cauchys_real?")
          (("" (inst + "expT(1)")
            (("" (expand "cauchys_prop") (("" (propax) nil nil)) nil))
            nil))
          nil))
        nil)
       ((cauchys_real? const-decl "bool" sum nil)
        (cauchys_prop const-decl "bool" sum nil)
        (expT const-decl "real" ln_exp_series_alt "lnexp_fnd/")
        (nat nonempty-type-eq-decl nil naturalnumbers nil)
        (>= const-decl "bool" reals nil)
        (bool nonempty-type-eq-decl nil booleans nil)
        (int nonempty-type-eq-decl nil integers nil)
        (integer_pred const-decl "[rational -> boolean]" integers nil)
        (rational nonempty-type-from-decl nil rationals nil)
        (rational_pred const-decl "[real -> boolean]" rationals nil)
        (real nonempty-type-from-decl nil reals nil)
        (real_pred const-decl "[number_field -> boolean]" reals nil)
        (number_field nonempty-type-from-decl nil number_fields nil)
        (number_field_pred const-decl "[number -> boolean]"
         number_fields nil)
        (boolean nonempty-type-decl nil booleans nil)
        (number nonempty-type-decl nil numbers nil)
        (exp_series_lemma formula-decl nil exp nil))
       nil))
     (exp_dr_lemma 0
      (exp_dr_lemma-2 nil 3508599234
       ("" (skosimp)
        (("" (expand "cauchy_prop" 1)
          (("" (skosimp)
            ((""
              (lemma "exp_estimate_lemma"
               ("x" "sx!1" "cx" "csx!1" "n" "p!1+3"))
              (("" (assert)
                (("" (expand "cauchy_exp_dr")
                  (("" (expand "cauchy_prop" -1)
                    (("" (inst - "2+p!1")
                      ((""
                        (name-replace "CPS"
                         "cauchy_powerseries(csx!1, cauchy_exp_series, 3 + p!1)(2 + p!1)")
                        (("" (flatten)
                          ((""
                            (case "abs(exp_estimate(sx!1,3+p!1)*2^p!1-CPS/4)<1/4")
                            (("1" (hide -2 -3)
                              (("1"
                                (lemma
                                 "lemma_A2"
                                 ("r"
                                  "round(CPS / 4)"
                                  "p"
                                  "CPS"
                                  "q"
                                  "4"))
                                (("1"
                                  (assert)
                                  (("1"
                                    (flatten)
                                    (("1"
                                      (case
                                       "abs(CPS/4-round(CPS / 4))<=1/2")
                                      (("1"
                                        (hide -2 -3)
                                        (("1"
                                          (case
                                           "abs(exp_estimate(sx!1, 3 + p!1) * 2 ^ p!1 - round(CPS / 4)) < 3 / 4")
                                          (("1"
                                            (hide -2 -3)
                                            (("1"
                                              (name-replace
                                               "RR"
                                               "round(CPS / 4)")
                                              (("1"
                                                (lemma
                                                 "exp_estimate_bnd"
                                                 ("x"
                                                  "sx!1"
                                                  "n"
                                                  "3+p!1"))
                                                (("1"
                                                  (case
                                                   "abs((exp(sx!1) - exp_estimate(sx!1, 3 + p!1))*2^p!1) <= 1/4")
                                                  (("1"
                                                    (hide -2 -4)
                                                    (("1"
                                                      (name-replace
                                                       "EXP_"
                                                       "exp(sx!1)")
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (hide-all-but
                                                     (-1 1))
                                                    (("2"
                                                      (lemma
                                                       "abs_mult"
                                                       ("x"
                                                        "exp(sx!1) - exp_estimate(sx!1, 3 + p!1)"
                                                        "y"
                                                        "2 ^ p!1"))
                                                      (("2"
                                                        (replace -1)
                                                        (("2"
                                                          (expand
                                                           "abs"
                                                           1
                                                           2)
                                                          (("2"
                                                            (hide -1)
                                                            (("2"
                                                              (case
                                                               "max(exp(sx!1), 1) * abs(sx!1) ^ (3 + p!1 + 1) /
                       factorial(3 + p!1 + 1) <= 1/(4*2^p!1)")
                                                              (("1"
                                                                (name-replace
                                                                 "LHS"
                                                                 "abs(exp(sx!1) - exp_estimate(sx!1, 3 + p!1))")
                                                                (("1"
                                                                  (name-replace
                                                                   "RHS"
                                                                   "max(exp(sx!1), 1) * abs(sx!1) ^ (3 + p!1 + 1) /
                   factorial(3 + p!1 + 1)")
                                                                  (("1"
                                                                    (rewrite
                                                                     "div_mult_pos_le2"
                                                                     1)
                                                                    (("1"
                                                                      (rewrite
                                                                       "div_mult_pos_le2"
                                                                       -1)
                                                                      (("1"
                                                                        (lemma
                                                                         "both_sides_times_pos_le1"
                                                                         ("pz"
                                                                          "4 * 2 ^ p!1"
                                                                          "x"
                                                                          "LHS"
                                                                          "y"
                                                                          "RHS"))
                                                                        (("1"
                                                                          (assert)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (hide-all-but
                                                                 1)
                                                                (("2"
                                                                  (case
                                                                   "max(exp(sx!1), 1) * abs(sx!1) ^ (3 + p!1 + 1))
                                                                  (("1"
                                                                    (case
                                                                     "12 * 2 ^ p!1 <= factorial(4 + p!1)")
                                                                    (("1"
                                                                      (case
                                                                       "exp(1)<3")
                                                                      (("1"
                                                                        (case-replace
                                                                         "sx!1=0")
                                                                        (("1"
                                                                          (expand
                                                                           "abs")
                                                                          (("1"
                                                                            (expand
                                                                             "^"
                                                                             1
                                                                             1)
                                                                            (("1"
                                                                              (expand
                                                                               "expt")
                                                                              (("1"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (lemma
                                                                           "lt_div_lt_pos2"
                                                                           ("nnx"
                                                                            "max(exp(sx!1), 1) * abs(sx!1) ^ (3 + p!1 + 1)"
                                                                            "y"
                                                                            "3"
                                                                            "pz"
                                                                            "12 * 2 ^ p!1"
                                                                            "w"
                                                                            "factorial(4 + p!1)"))
                                                                          (("2"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (hide-all-but
                                                                         1)
                                                                        (("2"
                                                                          (lemma
                                                                           "exp_strict_increasing")
                                                                          (("2"
                                                                            (expand
                                                                             "strict_increasing?")
                                                                            (("2"
                                                                              (inst
                                                                               -
                                                                               "1"
                                                                               "ln(3)")
                                                                              (("2"
                                                                                (rewrite
                                                                                 "exp_ln")
                                                                                (("2"
                                                                                  (split
                                                                                   -1)
                                                                                  (("1"
                                                                                    (propax)
                                                                                    nil
                                                                                    nil)
                                                                                   ("2"
                                                                                    (hide
                                                                                     2)
                                                                                    (("2"
                                                                                      (lemma
                                                                                       "ln_bounds"
                                                                                       ("px"
                                                                                        "3"
                                                                                        "n"
                                                                                        "4"))
                                                                                      (("2"
                                                                                        (name-replace
                                                                                         "LN3"
                                                                                         "ln(3)")
                                                                                        (("2"
                                                                                          (grind)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (hide-all-but
                                                                       1)
                                                                      (("2"
                                                                        (case
                                                                         "forall (m:nat): 12*2^m)
                                                                        (("1"
                                                                          (inst
                                                                           -
                                                                           "p!1")
                                                                          (("1"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (hide
                                                                           2)
                                                                          (("2"
                                                                            (induct
                                                                             "m")
                                                                            (("1"
                                                                              (grind)
                                                                              nil
                                                                              nil)
                                                                             ("2"
                                                                              (skosimp*)
                                                                              (("2"
                                                                                (rewrite
                                                                                 "expt_plus")
                                                                                (("2"
                                                                                  (expand
                                                                                   "factorial"
                                                                                   1)
                                                                                  (("2"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (hide
                                                                     2)
                                                                    (("2"
                                                                      (case-replace
                                                                       "sx!1=0")
                                                                      (("1"
                                                                        (rewrite
                                                                         "exp_0")
                                                                        (("1"
                                                                          (expand
                                                                           "max")
                                                                          (("1"
                                                                            (expand
                                                                             "abs")
                                                                            (("1"
                                                                              (expand
                                                                               "^")
                                                                              (("1"
                                                                                (expand
                                                                                 "expt")
                                                                                (("1"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (lemma
                                                                         "exp_strict_increasing")
                                                                        (("2"
                                                                          (expand
                                                                           "strict_increasing?")
                                                                          (("2"
                                                                            (inst
                                                                             -
                                                                             "sx!1"
                                                                             "1")
                                                                            (("2"
                                                                              (assert)
                                                                              (("2"
                                                                                (lemma
                                                                                 "both_sides_expt_pos_lt"
                                                                                 ("px"
                                                                                  "abs(sx!1)"
                                                                                  "py"
                                                                                  "1"
                                                                                  "pm"
                                                                                  "4+p!1"))
                                                                                (("2"
                                                                                  (rewrite
                                                                                   "expt_1i")
                                                                                  (("2"
                                                                                    (flatten)
                                                                                    (("2"
                                                                                      (hide
                                                                                       -1)
                                                                                      (("2"
                                                                                        (split
                                                                                         -1)
                                                                                        (("1"
                                                                                          (lemma
                                                                                           "both_sides_times_pos_lt1"
                                                                                           ("pz"
                                                                                            "max(exp(sx!1), 1)"
                                                                                            "x"
                                                                                            "abs(sx!1) ^ (4 + p!1)"
                                                                                            "y"
                                                                                            "1"))
                                                                                          (("1"
                                                                                            (assert)
                                                                                            (("1"
                                                                                              (case
                                                                                               "max(exp(sx!1), 1)<=e")
                                                                                              (("1"
                                                                                                (assert)
                                                                                                nil
                                                                                                nil)
                                                                                               ("2"
                                                                                                (hide-all-but
                                                                                                 (-3
                                                                                                  1))
                                                                                                (("2"
                                                                                                  (name-replace
                                                                                                   "EXP_"
                                                                                                   "exp(sx!1)")
                                                                                                  (("2"
                                                                                                    (expand
                                                                                                     "max")
                                                                                                    (("2"
                                                                                                      (case-replace
                                                                                                       "EXP_ < 1")
                                                                                                      (("1"
                                                                                                        (lemma
                                                                                                         "exp_strict_increasing")
                                                                                                        (("1"
                                                                                                          (expand
                                                                                                           "strict_increasing?")
                                                                                                          (("1"
                                                                                                            (inst
                                                                                                             -
                                                                                                             "0"
                                                                                                             "1")
                                                                                                            (("1"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil)
                                                                                                       ("2"
                                                                                                        (assert)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (hide-all-but
                                                                                           1)
                                                                                          (("2"
                                                                                            (grind)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (hide -3 2)
                                            (("2"
                                              (name-replace
                                               "RR"
                                               "round(CPS / 4)")
                                              (("2"
                                                (name-replace
                                                 "P2"
                                                 "2^p!1")
                                                (("2"
                                                  (name-replace
                                                   "EST"
                                                   "exp_estimate(sx!1, 3 + p!1)")
                                                  (("2"
                                                    (grind)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (hide -3 -4 2)
                                        (("2"
                                          (name-replace
                                           "RR"
                                           "round(CPS / 4)")
                                          (("2" (grind) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (hide -3 2)
                              (("2"
                                (rewrite "expt_plus")
                                (("2"
                                  (rewrite "expt_x2")
                                  (("2"
                                    (name-replace
                                     "EST"
                                     "exp_estimate(sx!1, 3 + p!1)")
                                    (("2"
                                      (name-replace "P2" "2^p!1")
                                      (("2" (grind) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ((posint_exp application-judgement "posint" exponentiation nil)
        (cauchy_prop const-decl "bool" cauchy nil)
        (smallreal nonempty-type-eq-decl nil prelude_aux nil)
        (- const-decl "[numfield -> numfield]" number_fields nil)
        (< const-decl "bool" reals nil)
        (AND const-decl "[bool, bool -> bool]" booleans nil)
        (+ const-decl "[numfield, numfield -> numfield]" number_fields
           nil)
        (numfield nonempty-type-eq-decl nil number_fields nil)
        (cauchy_smallreal nonempty-type-eq-decl nil cauchy nil)
        (cauchy_smallreal? const-decl "bool" cauchy nil)
        (cauchy_real nonempty-type-eq-decl nil cauchy nil)
        (cauchy_real? const-decl "bool" cauchy nil)
        (nat nonempty-type-eq-decl nil naturalnumbers nil)
        (>= const-decl "bool" reals nil)
        (bool nonempty-type-eq-decl nil booleans nil)
        (int nonempty-type-eq-decl nil integers nil)
        (integer_pred const-decl "[rational -> boolean]" integers nil)
        (rational nonempty-type-from-decl nil rationals nil)
        (rational_pred const-decl "[real -> boolean]" rationals nil)
        (real nonempty-type-from-decl nil reals nil)
        (real_pred const-decl "[number_field -> boolean]" reals nil)
        (number_field nonempty-type-from-decl nil number_fields nil)
        (number_field_pred const-decl "[number -> boolean]"
         number_fields nil)
        (boolean nonempty-type-decl nil booleans nil)
        (number nonempty-type-decl nil numbers nil)
        (exp_estimate_lemma formula-decl nil exp nil)
        (nnint_plus_posint_is_posint application-judgement "posint"
         integers nil)
        (cauchy_exp_dr const-decl "int" exp nil)
        (posint_plus_nnint_is_posint application-judgement "posint"
         integers nil)
        (expt_x2 formula-decl nil inv nil)
        (int_plus_int_is_int application-judgement "int" integers nil)
        (rat_plus_rat_is_rat application-judgement "rat" rationals nil)
        (mult_divides2 application-judgement "(divides(m))" divides
         nil)
        (mult_divides1 application-judgement "(divides(n))" divides
         nil)
        (even_times_int_is_even application-judgement "even_int"
         integers nil)
        (int_times_int_is_int application-judgement "int" integers nil)
        (rat_minus_rat_is_rat application-judgement "rat" rationals
         nil)
        (rat_times_rat_is_rat application-judgement "rat" rationals
         nil)
        (real_le_is_total_order name-judgement "(total_order?[real])"
         real_props nil)
        (<= const-decl "bool" reals nil)
        (posreal nonempty-type-eq-decl nil real_types nil)
        (ln const-decl "real" ln_exp "lnexp_fnd/")
        (exp const-decl "{py | x = ln(py)}" ln_exp "lnexp_fnd/")
        (minus_odd_is_odd application-judgement "odd_int" integers nil)
        (abs_mult formula-decl nil real_props nil)
        (nnreal_div_posreal_is_nnreal application-judgement "nnreal"
         real_types nil)
        (posint_times_posint_is_posint application-judgement "posint"
         integers nil)
        (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
        (factorial def-decl "posnat" factorial "ints/")
        (nnreal type-eq-decl nil real_types nil)
        (both_sides_times_pos_le1 formula-decl nil real_props nil)
        (div_mult_pos_le2 formula-decl nil real_props nil)
        (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
         integers nil)
        (expt_x1 formula-decl nil exponentiation nil)
        (expt_plus formula-decl nil exponentiation nil)
        (nzreal nonempty-type-eq-decl nil reals nil)
        (even_plus_even_is_even application-judgement "even_int"
         integers nil)
        (real_ge_is_total_order name-judgement "(total_order?[real])"
         real_props nil)
        (posnat_expt application-judgement "posnat" exponentiation nil)
        (nat_induction formula-decl nil naturalnumbers nil)
        (pred type-eq-decl nil defined_types nil)
        (lt_div_lt_pos2 formula-decl nil real_props nil)
        (expt def-decl "real" exponentiation nil)
        (nat_exp application-judgement "nat" exponentiation nil)
        (nnrat_div_posrat_is_nnrat application-judgement "nonneg_rat"
         rationals nil)
        (hat_02n formula-decl nil power_series "series/")
        (exp_0 formula-decl nil ln_exp "lnexp_fnd/")
        (exp_1 formula-decl nil ln_exp "lnexp_fnd/")
        (exp_strict_increasing formula-decl nil ln_exp "lnexp_fnd/")
        (ln_bounds formula-decl nil ln_approx "lnexp_fnd/")
        (real_plus_real_is_real application-judgement "real" reals nil)
        (nzrat_div_nzrat_is_nzrat application-judgement "nzrat"
         rationals nil)
        (real_gt_is_strict_total_order name-judgement
         "(strict_total_order?[real])" real_props nil)
        (minus_nzint_is_nzint application-judgement "nzint" integers
         nil)
        (nzint_times_nzint_is_nzint application-judgement "nzint"
         integers nil)
        (int_expt application-judgement "int" exponentiation nil)
        (nzreal_expt application-judgement "nzreal" exponentiation nil)
        (minus_nzrat_is_nzrat application-judgement "nzrat" rationals
         nil)
        (nzrat_times_nzrat_is_nzrat application-judgement "nzrat"
         rationals nil)
        (rat_expt application-judgement "rat" exponentiation nil)
        (ln_ub const-decl "real" ln_approx "lnexp_fnd/")
        (ln_gt1_ub const-decl "real" ln_approx "lnexp_fnd/")
        (ln_le2_ub const-decl "real" ln_approx "lnexp_fnd/")
        (ln_lb const-decl "real" ln_approx "lnexp_fnd/")
        (ln_gt1_lb const-decl "real" ln_approx "lnexp_fnd/")
        (ln_le2_lb const-decl "real" ln_approx "lnexp_fnd/")
        (ln_estimate const-decl "real" ln_series "lnexp_fnd/")
        (sigma def-decl "real" sigma "reals/")
        (log_nat def-decl "[n: nat, {y | y < p AND x = p ^ n * y}]"
         log_nat "reals/")
        (exp_ln formula-decl nil ln_exp "lnexp_fnd/")
        (strict_increasing? const-decl "bool" real_fun_preds "reals/")
        (expt_1i formula-decl nil exponentiation nil)
        (both_sides_times_pos_lt1 formula-decl nil real_props nil)
        (e const-decl "posreal" ln_exp "lnexp_fnd/")
        (both_sides_expt_pos_lt formula-decl nil exponentiation nil)
        (nnreal_times_nnreal_is_nnreal application-judgement "nnreal"
         real_types nil)
        (nnreal_exp application-judgement "nnreal" exponentiation nil)
        (posreal_max application-judgement
         "{z: posreal | z >= x AND z >= y}" real_defs nil)
        (exp_estimate_bnd formula-decl nil ln_exp_series_alt
         "lnexp_fnd/")
        (minus_real_is_real application-judgement "real" reals nil)
        (rat_abs_is_nonneg application-judgement
         "{r: nonneg_rat | r >= q}" real_defs nil)
        (minus_rat_is_rat application-judgement "rat" rationals nil)
        (posint nonempty-type-eq-decl nil integers nil)
        (even_minus_even_is_even application-judgement "even_int"
         integers nil)
        (round const-decl "int" prelude_aux nil)
        (posnat nonempty-type-eq-decl nil integers nil)
        (> const-decl "bool" reals nil)
        (nonneg_int nonempty-type-eq-decl nil integers nil)
        (lemma_A2 formula-decl nil appendix nil)
        (/ const-decl "[numfield, nznum -> numfield]" number_fields
           nil)
        (nznum nonempty-type-eq-decl nil number_fields nil)
        (^ const-decl "real" exponentiation nil)
        (/= const-decl "boolean" notequal nil)
        (OR const-decl "[bool, bool -> bool]" booleans nil)
        (exp_estimate const-decl "real" ln_exp_series_alt "lnexp_fnd/")
        (* const-decl "[numfield, numfield -> numfield]" number_fields
           nil)
        (- const-decl "[numfield, numfield -> numfield]" number_fields
           nil)
        (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}"
             real_defs nil)
        (nonneg_real nonempty-type-eq-decl nil real_types nil)
        (posrat_div_posrat_is_posrat application-judgement "posrat"
         rationals nil)
        (real_minus_real_is_real application-judgement "real" reals
         nil)
        (real_times_real_is_real application-judgement "real" reals
         nil)
        (rat_div_nzrat_is_rat application-judgement "rat" rationals
         nil)
        (= const-decl "[T, T -> boolean]" equalities nil)
        (cauchys_real? const-decl "bool" sum nil)
        (cauchys_real nonempty-type-eq-decl nil sum nil)
        (cauchy_powerseries const-decl "cauchy_real" powerseries nil)
        (cauchy_nnreal? const-decl "bool" cauchy nil)
        (cauchy_nnreal nonempty-type-eq-decl nil cauchy nil)
        (cauchy_exp_series const-decl "cauchy_nnreal" exp nil)
        (real_lt_is_strict_total_order name-judgement
         "(strict_total_order?[real])" real_props nil)
        (int_minus_int_is_int application-judgement "int" integers nil)
        (posreal_times_posreal_is_posreal application-judgement
         "posreal" real_types nil))
       nil)
      (exp_dr_lemma-1 nil 3394186556
       ("" (skosimp)
        (("" (expand "cauchy_prop" 1)
          (("" (skosimp)
            ((""
              (lemma "exp_estimate_lemma"
               ("x" "sx!1" "cx" "csx!1" "n" "p!1+3"))
              (("" (assert)
                (("" (expand "cauchy_exp_dr")
                  (("" (expand "cauchy_prop" -1)
                    (("" (inst - "2+p!1")
                      ((""
                        (name-replace "CPS"
                         "cauchy_powerseries(csx!1, cauchy_exp_series, 3 + p!1)(2 + p!1)")
                        (("" (flatten)
                          ((""
                            (case "abs(exp_estimate(sx!1,3+p!1)*2^p!1-CPS/4)<1/4")
                            (("1" (hide -2 -3)
                              (("1"
                                (lemma
                                 "lemma_A2"
                                 ("r"
                                  "round(CPS / 4)"
                                  "p"
                                  "CPS"
                                  "q"
                                  "4"))
                                (("1"
                                  (assert)
                                  (("1"
                                    (flatten)
                                    (("1"
                                      (case
                                       "abs(CPS/4-round(CPS / 4))<=1/2")
                                      (("1"
                                        (hide -2 -3)
                                        (("1"
                                          (case
                                           "abs(exp_estimate(sx!1, 3 + p!1) * 2 ^ p!1 - round(CPS / 4)) < 3 / 4")
                                          (("1"
                                            (hide -2 -3)
                                            (("1"
                                              (name-replace
                                               "RR"
                                               "round(CPS / 4)")
                                              (("1"
                                                (lemma
                                                 "exp_estimate_bnd"
                                                 ("x"
                                                  "sx!1"
                                                  "n"
                                                  "3+p!1"))
                                                (("1"
                                                  (case
                                                   "abs((exp(sx!1) - exp_estimate(sx!1, 3 + p!1))*2^p!1) <= 1/4")
                                                  (("1"
                                                    (hide -2 -4)
                                                    (("1"
                                                      (name-replace
                                                       "EXP"
                                                       "exp(sx!1)")
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (hide-all-but
                                                     (-1 1))
                                                    (("2"
                                                      (lemma
                                                       "abs_mult"
                                                       ("x"
                                                        "exp(sx!1) - exp_estimate(sx!1, 3 + p!1)"
                                                        "y"
                                                        "2 ^ p!1"))
                                                      (("2"
                                                        (replace -1)
                                                        (("2"
                                                          (expand
                                                           "abs"
                                                           1
                                                           2)
                                                          (("2"
                                                            (hide -1)
                                                            (("2"
                                                              (case
                                                               "max(exp(sx!1), 1) * abs(sx!1) ^ (3 + p!1 + 1) /
        factorial(3 + p!1 + 1) <= 1/(4*2^p!1)")
                                                              (("1"
                                                                (name-replace
                                                                 "LHS"
                                                                 "abs(exp(sx!1) - exp_estimate(sx!1, 3 + p!1))")
                                                                (("1"
                                                                  (name-replace
                                                                   "RHS"
--> --------------------

--> maximum size reached

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

¤ Dauer der Verarbeitung: 0.82 Sekunden  (vorverarbeitet)  ¤



Download des
Quellennavigators
Download des
sprechenden Kalenders

in der Quellcodebibliothek suchen




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 ist noch experimentell.


Bot Zugriff