products/Sources/formale Sprachen/PVS/ints image not shown  

Quellcode-Bibliothek

© Kompilation durch diese Firma

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

Datei: sigma_fseq.prf   Sprache: Lisp

Original von: PVS©

(exp_approx
 (exp_neg_le1_bounds 0
  (exp_neg_le1_bounds-3 nil 3307800311
   ("" (expand "exp_neg_le1_lb")
    (("" (expand "exp_neg_le1_ub")
      (("" (skosimp)
        (("" (case "FORALL (n:nat): 0 < x!1^(2*n) & x!1^(2*n) <= 1")
          (("1"
            (case "FORALL (n:nat): -1 <= x!1^(2*n+1) & x!1^(2*n+1) < 0")
            (("1" (case "max(exp(x!1), 1) = 1")
              (("1"
                (case "FORALL (n,m:posnat): n < m => abs(x!1)^m/factorial(m) < abs(x!1)^n/factorial(n)")
                (("1"
                  (case-replace "FORALL (n: nat, x: real):
                  exp_estimate(x, n) =
                   sigma(0, n,
                         LAMBDA (nn: nat):
                           IF nn = 0 THEN 1 ELSE x ^ nn / factorial(nn) ENDIF)")
                  (("1" (hide -1)
                    (("1"
                      (case-replace
                       "exp_estimate(x!1, 1 + 2 * n!1) < exp(x!1)")
                      (("1"
                        (lemma "exp_taylors_err"
                         ("x" "x!1" "n" "1+2*n!1"))
                        (("1" (reveal -1)
                          (("1" (copy -1)
                            (("1" (inst?)
                              (("1"
                                (replace -1)
                                (("1"
                                  (hide -1)
                                  (("1"
                                    (inst?)
                                    (("1"
                                      (replace -1)
                                      (("1"
                                        (hide -1)
                                        (("1"
                                          (expand "abs" -1 1)
                                          (("1"
                                            (assert)
                                            (("1"
                                              (replace -4)
                                              (("1"
                                                (hide -2)
                                                (("1"
                                                  (expand "sigma" -1 1)
                                                  (("1"
                                                    (name-replace
                                                     "RHS"
                                                     "sigma(0, 2 * n!1,
                                                   LAMBDA (nn: nat):
                                                     IF nn = 0 THEN 1 ELSE x!1 ^ nn / factorial(nn) ENDIF)")
                                                    (("1"
                                                      (case
                                                       "(x!1^(1+2*n!1))/factorial(1+2*n!1) + abs(x!1)^(2+2*n!1)/factorial(2+2*n!1) < 0")
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil)
                                                       ("2"
                                                        (inst
                                                         -2
                                                         "1+2*n!1"
                                                         "2+2*n!1")
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (case-replace
                                                             "abs(x!1) ^ (1 + 2 * n!1) = -(x!1^(1+2*n!1))")
                                                            (("1"
                                                              (assert)
                                                              nil
                                                              nil)
                                                             ("2"
                                                              (hide
                                                               2
                                                               3
                                                               -1
                                                               -3)
                                                              (("2"
                                                                (hide
                                                                 -1
                                                                 -2
                                                                 -3)
                                                                (("2"
                                                                  (rewrite
                                                                   "expt_plus")
                                                                  (("2"
                                                                    (rewrite
                                                                     "expt_plus")
                                                                    (("2"
                                                                      (rewrite
                                                                       "expt_times")
                                                                      (("2"
                                                                        (rewrite
                                                                         "expt_times")
                                                                        (("2"
                                                                          (expand
                                                                           "abs")
                                                                          (("2"
                                                                            (case-replace
                                                                             "(-x!1) ^ 2=x!1 ^ 2")
                                                                            (("1"
                                                                              (assert)
                                                                              (("1"
                                                                                (hide
                                                                                 -1)
                                                                                (("1"
                                                                                  (grind)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (hide
                                                                               2)
                                                                              (("2"
                                                                                (expand
                                                                                 "^")
                                                                                (("2"
                                                                                  (expand
                                                                                   "expt")
                                                                                  (("2"
                                                                                    (expand
                                                                                     "expt")
                                                                                    (("2"
                                                                                      (expand
                                                                                       "expt")
                                                                                      (("2"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (hide 2)
                        (("2"
                          (lemma "exp_taylors_err"
                           ("x" "x!1" "n" "2+2*n!1"))
                          (("2" (reveal -1)
                            (("2" (inst?)
                              (("2"
                                (replace -1)
                                (("2"
                                  (hide -1)
                                  (("2"
                                    (reveal -2)
                                    (("2"
                                      (inst?)
                                      (("2"
                                        (replace -1)
                                        (("2"
                                          (hide -1)
                                          (("2"
                                            (replace -3)
                                            (("2"
                                              (expand "abs" -1 1)
                                              (("2"
                                                (expand "sigma" -1)
                                                (("2"
                                                  (name-replace
                                                   "LB"
                                                   "sigma(0, 1 + 2 * n!1,
                                                  LAMBDA (nn: nat):
                                                    IF nn = 0 THEN 1 ELSE x!1 ^ nn / factorial(nn) ENDIF)")
                                                  (("2"
                                                    (case-replace
                                                     "exp(x!1) - LB - (x!1 ^ (2 + 2 * n!1)) / factorial(2 + 2 * n!1) < 0")
                                                    (("1"
                                                      (hide -1)
                                                      (("1"
                                                        (case
                                                         "x!1^(2+2*n!1) / factorial(2+2*n!1) - abs(x!1)^(3+2*n!1)/factorial(3+2*n!1) > 0")
                                                        (("1"
                                                          (assert)
                                                          nil
                                                          nil)
                                                         ("2"
                                                          (hide -1 2)
                                                          (("2"
                                                            (inst
                                                             -
                                                             "2+2*n!1"
                                                             "3+2*n!1")
                                                            (("2"
                                                              (assert)
                                                              (("2"
                                                                (case-replace
                                                                 "abs(x!1) ^ (2 + 2 * n!1) = x!1 ^ (2 + 2 * n!1)")
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil)
                                                                 ("2"
                                                                  (hide
                                                                   -1
                                                                   2)
                                                                  (("2"
                                                                    (lemma
                                                                     "expt_times"
                                                                     ("i"
                                                                      "2"
                                                                      "j"
                                                                      "1+n!1"))
                                                                    (("2"
                                                                      (inst-cp
                                                                       -
                                                                       "abs(x!1)")
                                                                      (("2"
                                                                        (inst
                                                                         -
                                                                         "x!1")
                                                                        (("2"
                                                                          (case-replace
                                                                           "abs(x!1)^2 = x!1^2")
                                                                          (("1"
                                                                            (assert)
                                                                            nil
                                                                            nil)
                                                                           ("2"
                                                                            (hide-all-but
                                                                             (-7
                                                                              1))
                                                                            (("2"
                                                                              (expand
                                                                               "^")
                                                                              (("2"
                                                                                (expand
                                                                                 "expt")
                                                                                (("2"
                                                                                  (expand
                                                                                   "expt")
                                                                                  (("2"
                                                                                    (expand
                                                                                     "expt")
                                                                                    (("2"
                                                                                      (expand
                                                                                       "abs")
                                                                                      (("2"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (hide -1)
                                                      (("2"
                                                        (case
                                                         "(x!1 ^ (2 + 2 * n!1)) / factorial(2 + 2 * n!1) > 0")
                                                        (("1"
                                                          (assert)
                                                          nil
                                                          nil)
                                                         ("2"
                                                          (hide 2 3)
                                                          (("2"
                                                            (inst
                                                             -4
                                                             "1+n!1")
                                                            (("2"
                                                              (flatten)
                                                              (("2"
                                                                (lemma
                                                                 "posreal_div_posreal_is_posreal"
                                                                 ("px"
                                                                  "x!1 ^ (2 + 2 * n!1)"
                                                                  "py"
                                                                  "factorial(2 + 2 * n!1)"))
                                                                (("1"
                                                                  (propax)
                                                                  nil
                                                                  nil)
                                                                 ("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)
                   ("2" (hide-all-but 1)
                    (("2" (skosimp*)
                      (("2" (expand "exp_estimate")
                        (("2" (lemma "sigma_first")
                          (("2"
                            (inst - "LAMBDA (nn: nat):
                             IF nn = 0 THEN 1 ELSE x!2 ^ nn / factorial(nn) ENDIF"
                             "n!2" "0")
                            (("2" (case-replace "n!2 > 0 ")
                              (("1"
                                (assert)
                                (("1"
                                  (replace -2)
                                  (("1"
                                    (assert)
                                    (("1"
                                      (hide -2)
                                      (("1"
                                        (rewrite "sigma_restrict_eq")
                                        (("1"
                                          (hide 2)
                                          (("1"
                                            (expand "restrict")
                                            (("1" (propax) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (case-replace "n!2 = 0")
                                (("1"
                                  (assert)
                                  (("1"
                                    (hide -2)
                                    (("1"
                                      (expand "sigma")
                                      (("1"
                                        (expand "sigma")
                                        (("1" (propax) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2" (assertnil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (hide-all-but (-4 -5 1))
                  (("2" (skosimp)
                    (("2"
                      (case "forall (n,m:posnat): factorial(n) < factorial(n+m)")
                      (("1" (case "abs(x!1) ^ m!1 <= abs(x!1) ^ n!2")
                        (("1"
                          (lemma "lt_div_lt_pos1"
                           ("px" "abs(x!1) ^ m!1" "w" "factorial(m!1)"
                            "y" "abs(x!1) ^ n!2" "pz"
                            "factorial(n!2)"))
                          (("1" (split -1)
                            (("1" (propax) nil nil)
                             ("2" (propax) nil nil)
                             ("3" (inst - "n!2" "m!1-n!2")
                              (("1" (assertnil nil)
                               ("2" (assertnil nil))
                              nil))
                            nil)
                           ("2"
                            (lemma "expt_pos"
                             ("px" "abs(x!1)" "i" "m!1"))
                            (("1" (propax) nil nil)
                             ("2" (expand "abs")
                              (("2" (assertnil nil)) nil))
                            nil))
                          nil)
                         ("2" (hide 2 -1)
                          (("2" (case-replace "abs(x!1)=1")
                            (("1" (rewrite "expt_1i")
                              (("1"
                                (rewrite "expt_1i")
                                (("1" (assertnil nil))
                                nil))
                              nil)
                             ("2" (case "abs(x!1)<1")
                              (("1"
                                (lemma
                                 "both_sides_expt_lt1_lt"
                                 ("lt1x"
                                  "abs(x!1)"
                                  "i"
                                  "m!1"
                                  "j"
                                  "n!2"))
                                (("1" (assertnil nil)
                                 ("2" (assertnil nil))
                                nil)
                               ("2"
                                (expand "abs")
                                (("2" (assertnil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (hide -2 -3 2)
                        (("2" (hide -1)
                          (("2" (induct "m")
                            (("1" (assertnil nil)
                             ("2" (assertnil nil)
                             ("3" (skosimp*)
                              (("3"
                                (case-replace "j!1=0")
                                (("1"
                                  (expand "factorial" 1 2)
                                  (("1"
                                    (lemma
                                     "both_sides_times_pos_lt1"
                                     ("pz"
                                      "factorial(n!3)"
                                      "x"
                                      "1"
                                      "y"
                                      "1+n!3"))
                                    (("1" (assertnil nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (assert)
                                  (("2"
                                    (inst - "n!3")
                                    (("2"
                                      (expand "factorial" 2 2)
                                      (("2" (assertnil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (hide-all-but (-4 1))
                (("2" (expand "max")
                  (("2" (lemma "exp_strict_increasing")
                    (("2" (expand "strict_increasing?")
                      (("2" (inst - "x!1" "0")
                        (("2" (rewrite "exp_0")
                          (("2" (assertnil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (hide 2)
              (("2" (skosimp)
                (("2" (inst - "n!2")
                  (("2" (flatten)
                    (("2" (rewrite "expt_plus" 1)
                      (("2"
                        (lemma "both_sides_times_neg_lt1"
                         ("nz" "x!1" "y" "0" "x" "x!1^(2*n!2)"))
                        (("1"
                          (lemma "both_sides_times_neg_le1"
                           ("nz" "x!1" "x" "1" "y" "x!1^(2*n!2)"))
                          (("1" (assert)
                            (("1" (name-replace "AA" "x!1 ^ (2 * n!2)")
                              (("1" (grind) nil nil)) nil))
                            nil))
                          nil)
                         ("2" (assertnil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (hide 2)
            (("2" (skosimp)
              (("2" (rewrite "expt_times" 1)
                (("2" (case "0 < x!1^2 & x!1^2<=1")
                  (("1" (flatten)
                    (("1" (lemma "expt_pos" ("i" "n!2" "px" "x!1^2"))
                      (("1" (expand "<=" -3)
                        (("1" (split -3)
                          (("1" (case-replace "n!2=0")
                            (("1" (rewrite "expt_x0")
                              (("1" (assertnil nil)) nil)
                             ("2"
                              (lemma "both_sides_expt_pos_lt"
                               ("px" "x!1^2" "py" "1" "pm" "n!2"))
                              (("1"
                                (rewrite "expt_1i")
                                (("1" (assertnil nil))
                                nil)
                               ("2" (assertnil nil))
                              nil))
                            nil)
                           ("2" (replace -1)
                            (("2" (rewrite "expt_1i")
                              (("2" (assertnil nil)) nil))
                            nil))
                          nil))
                        nil)
                       ("2" (assertnil nil))
                      nil))
                    nil)
                   ("2" (hide 2)
                    (("2"
                      (lemma "negreal_times_negreal_is_posreal"
                       ("nx" "x!1" "ny" "x!1"))
                      (("1" (lemma "le_times_le_neg")
                        (("1" (inst - "x!1" "x!1" "-1" "-1")
                          (("1" (expand "^")
                            (("1" (expand "expt")
                              (("1"
                                (expand "expt")
                                (("1"
                                  (expand "expt")
                                  (("1" (assertnil nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (assertnil nil))
                          nil))
                        nil)
                       ("2" (assertnil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((exp_neg_le1_ub const-decl "real" exp_approx nil)
    (<= const-decl "bool" reals nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield 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)
    (< const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans 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)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (both_sides_times_neg_le1 formula-decl nil real_props nil)
    (negreal nonempty-type-eq-decl nil real_types nil)
    (nonpos_real nonempty-type-eq-decl nil real_types nil)
    (both_sides_times_neg_lt1 formula-decl nil real_props nil)
    (posreal_max application-judgement
     "{z: posreal | z >= x AND z >= y}" real_defs nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (ln const-decl "real" ln_exp nil)
    (exp const-decl "{py | x = ln(py)}" ln_exp nil)
    (both_sides_expt_lt1_lt formula-decl nil exponentiation nil)
    (expt_1i formula-decl nil exponentiation nil)
    (lt_div_lt_pos1 formula-decl nil real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (m!1 skolem-const-decl "posnat" exp_approx nil)
    (n!2 skolem-const-decl "posnat" exp_approx nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (expt_pos formula-decl nil exponentiation nil)
    (both_sides_times_pos_lt1 formula-decl nil real_props nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (sigma def-decl "real" sigma "reals/")
    (T_high type-eq-decl nil sigma "reals/")
    (T_low type-eq-decl nil sigma "reals/")
    (exp_estimate const-decl "real" exp_series nil)
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nnreal_exp application-judgement "nnreal" exponentiation nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (nzreal nonempty-type-eq-decl nil reals nil)
    (expt_plus formula-decl nil exponentiation nil)
    (expt_times formula-decl nil exponentiation nil)
    (expt def-decl "real" exponentiation nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (minus_real_is_real application-judgement "real" reals nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (even_plus_even_is_even application-judgement "even_int" integers
     nil)
    (nnreal_times_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (exp_taylors_err formula-decl nil exp_series nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (posreal_div_posreal_is_posreal judgement-tcc nil real_types nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (sigma_first formula-decl nil sigma "reals/")
    (restrict const-decl "[T -> real]" sigma "reals/")
    (sigma_restrict_eq formula-decl nil sigma "reals/")
    (factorial def-decl "posnat" factorial "ints/")
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (nnreal_div_posreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (strict_increasing? const-decl "bool" real_fun_preds "reals/")
    (exp_0 formula-decl nil ln_exp nil)
    (exp_strict_increasing formula-decl nil ln_exp nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (even_plus_odd_is_odd application-judgement "odd_int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (both_sides_expt_pos_lt formula-decl nil exponentiation nil)
    (expt_x0 formula-decl nil exponentiation nil)
    (negreal_times_negreal_is_posreal judgement-tcc nil real_types nil)
    (x!1 skolem-const-decl "real" exp_approx nil)
    (le_times_le_neg formula-decl nil real_props nil)
    (exp_neg_le1_lb const-decl "real" exp_approx 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)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil))
   nil)
  (exp_neg_le1_bounds-2 nil 3307367265
   ("" (expand "exp_neg_le1_lb")
    (("" (expand "exp_neg_le1_ub")
      (("" (skosimp)
        (("" (case "FORALL (n:nat): 0 < x!1^(2*n) & x!1^(2*n) <= 1")
          (("1"
            (case "FORALL (n:nat): -1 <= x!1^(2*n+1) & x!1^(2*n+1) < 0")
            (("1" (case "max(exp(x!1), 1) = 1")
              (("1"
                (case "FORALL (n,m:posnat): n < m => abs(x!1)^m/factorial(m) < abs(x!1)^n/factorial(n)")
                (("1"
                  (case-replace
                   "exp_estimate(x!1, 1 + 2 * n!1) < exp(x!1)")
                  (("1" (lemma "exp_series" ("x" "x!1" "n" "1+2*n!1"))
                    (("1" (expand "abs" -1 1)
                      (("1" (assert)
                        (("1" (replace -4)
                          (("1" (hide -2)
                            (("1" (expand "exp_estimate")
                              (("1"
                                (expand "sigma" -1 1)
                                (("1"
                                  (name-replace
                                   "RHS"
                                   "sigma(0, 2 * n!1,
                         LAMBDA (nn: nat):
                           IF nn = 0 THEN 1 ELSE x!1 ^ nn / factorial(nn) ENDIF)")
                                  (("1"
                                    (case
                                     "(x!1^(1+2*n!1))/factorial(1+2*n!1) + abs(x!1)^(2+2*n!1)/factorial(2+2*n!1) < 0")
                                    (("1" (assertnil)
                                     ("2"
                                      (inst -2 "1+2*n!1" "2+2*n!1")
                                      (("2"
                                        (assert)
                                        (("2"
                                          (case-replace
                                           "abs(x!1) ^ (1 + 2 * n!1) = -(x!1^(1+2*n!1))")
                                          (("1" (assertnil)
                                           ("2"
                                            (hide 2 3 -1 -3)
                                            (("2"
                                              (hide -1 -2 -3)
                                              (("2"
                                                (rewrite "expt_plus")
                                                (("1"
                                                  (rewrite "expt_plus")
                                                  (("1"
                                                    (rewrite "expt_x1")
                                                    (("1"
                                                      (rewrite
                                                       "expt_x1")
                                                      (("1"
                                                        (rewrite
                                                         "expt_times")
                                                        (("1"
                                                          (rewrite
                                                           "expt_times")
                                                          (("1"
                                                            (expand
                                                             "abs")
                                                            (("1"
                                                              (case-replace
                                                               "(-x!1) ^ 2=x!1 ^ 2")
                                                              (("1"
                                                                (assert)
                                                                nil)
                                                               ("2"
                                                                (hide
                                                                 2)
                                                                (("2"
                                                                  (expand
                                                                   "^")
                                                                  (("2"
                                                                    (expand
                                                                     "expt")
                                                                    (("2"
                                                                      (expand
                                                                       "expt")
                                                                      (("2"
                                                                        (expand
                                                                         "expt")
                                                                        (("2"
                                                                          (assert)
                                                                          nil)))))))))))))))))
                                                         ("2"
                                                          (expand
                                                           "abs")
                                                          (("2"
                                                            (assert)
                                                            nil)))))))))))
                                                 ("2"
                                                  (expand "abs")
                                                  (("2"
                                                    (assert)
                                                    nil)))))))))))))))))))))))))))))))))
                   ("2" (hide 2)
                    (("2"
                      (lemma "exp_series" ("x" "x!1" "n" "2+2*n!1"))
                      (("2" (replace -3)
                        (("2" (expand "abs" -1 1)
                          (("2" (expand "exp_estimate")
                            (("2" (expand "sigma" -1)
                              (("2"
                                (name-replace
                                 "LB"
                                 "sigma(0, 1 + 2 * n!1,
                        LAMBDA (nn: nat):
                          IF nn = 0 THEN 1 ELSE x!1 ^ nn / factorial(nn) ENDIF)")
                                (("2"
                                  (case-replace
                                   "exp(x!1) - LB - (x!1 ^ (2 + 2 * n!1)) / factorial(2 + 2 * n!1) < 0")
                                  (("1"
                                    (hide -1)
                                    (("1"
                                      (case
                                       "x!1^(2+2*n!1) / factorial(2+2*n!1) - abs(x!1)^(3+2*n!1)/factorial(3+2*n!1) > 0")
                                      (("1" (assertnil)
                                       ("2"
                                        (hide -1 2)
                                        (("2"
                                          (inst - "2+2*n!1" "3+2*n!1")
                                          (("2"
                                            (assert)
                                            (("2"
                                              (case-replace
                                               "abs(x!1) ^ (2 + 2 * n!1) = x!1 ^ (2 + 2 * n!1)")
                                              (("1" (assertnil)
                                               ("2"
                                                (hide -1 2)
                                                (("2"
                                                  (lemma
                                                   "expt_times"
                                                   ("i"
                                                    "2"
                                                    "j"
                                                    "1+n!1"))
                                                  (("2"
                                                    (inst-cp
                                                     -
                                                     "abs(x!1)")
                                                    (("1"
                                                      (inst - "x!1")
                                                      (("1"
                                                        (case-replace
                                                         "abs(x!1)^2 = x!1^2")
                                                        (("1"
                                                          (assert)
                                                          nil)
                                                         ("2"
                                                          (hide-all-but
                                                           (-7 1))
                                                          (("2"
                                                            (expand
                                                             "^")
                                                            (("2"
                                                              (expand
                                                               "expt")
                                                              (("2"
                                                                (expand
                                                                 "expt")
                                                                (("2"
                                                                  (expand
                                                                   "expt")
                                                                  (("2"
                                                                    (expand
                                                                     "abs")
                                                                    (("2"
                                                                      (assert)
                                                                      nil)))))))))))))))))
                                                     ("2"
                                                      (expand "abs")
                                                      (("2"
                                                        (assert)
                                                        nil)))))))))))))))))))))
                                   ("2"
                                    (hide -1)
                                    (("2"
                                      (case
                                       "(x!1 ^ (2 + 2 * n!1)) / factorial(2 + 2 * n!1) > 0")
                                      (("1" (assertnil)
                                       ("2"
                                        (hide 2 3)
                                        (("2"
                                          (inst -4 "1+n!1")
                                          (("2"
                                            (flatten)
                                            (("2"
                                              (lemma
                                               "posreal_div_posreal_is_posreal"
                                               ("px"
                                                "x!1 ^ (2 + 2 * n!1)"
                                                "py"
                                                "factorial(2 + 2 * n!1)"))
                                              (("1" (propax) nil)
                                               ("2"
                                                (assert)
                                                nil)))))))))))))))))))))))))))))))
                 ("2" (hide-all-but (-4 -5 1))
                  (("2" (skosimp)
                    (("2"
                      (case "forall (n,m:posnat): factorial(n) < factorial(n+m)")
                      (("1" (case "abs(x!1) ^ m!1 <= abs(x!1) ^ n!2")
                        (("1"
                          (lemma "lt_div_lt_pos1"
                           ("px" "abs(x!1) ^ m!1" "w" "factorial(m!1)"
                            "y" "abs(x!1) ^ n!2" "pz"
                            "factorial(n!2)"))
                          (("1" (split -1)
                            (("1" (propax) nil) ("2" (propax) nil)
                             ("3" (inst - "n!2" "m!1-n!2")
                              (("1" (assertnil)
                               ("2" (assertnil)))))
                           ("2"
                            (lemma "expt_pos"
                             ("px" "abs(x!1)" "i" "m!1"))
                            (("1" (propax) nil)
                             ("2" (expand "abs")
                              (("2" (assertnil)))))))
                         ("2" (hide 2 -1)
                          (("2" (case-replace "abs(x!1)=1")
                            (("1" (rewrite "expt_1i")
                              (("1"
                                (rewrite "expt_1i")
                                (("1" (assertnil)))))
                             ("2" (case "abs(x!1)<1")
                              (("1"
                                (lemma
                                 "both_sides_expt_lt1_lt"
                                 ("lt1x"
                                  "abs(x!1)"
                                  "i"
                                  "m!1"
                                  "j"
                                  "n!2"))
                                (("1" (assertnil)
                                 ("2"
                                  (assert)
                                  (("2"
                                    (expand "abs")
                                    (("2" (assertnil)))))))
                               ("2"
                                (expand "abs")
                                (("2" (assertnil)))))))))))
                       ("2" (hide -2 -3 2)
                        (("2" (hide -1)
                          (("2" (induct "m")
                            (("1" (assertnil) ("2" (assertnil)
                             ("3" (skosimp*)
                              (("3"
                                (case-replace "j!1=0")
                                (("1"
                                  (expand "factorial" 1 2)
                                  (("1"
                                    (lemma
                                     "both_sides_times_pos_lt1"
                                     ("pz"
                                      "factorial(n!3)"
                                      "x"
                                      "1"
                                      "y"
                                      "1+n!3"))
                                    (("1" (assertnil)))))
                                 ("2"
                                  (assert)
                                  (("2"
                                    (inst - "n!3")
                                    (("2"
                                      (expand "factorial" 2 2)
                                      (("2"
                                        (assert)
                                        nil)))))))))))))))))))))))))
               ("2" (hide-all-but (-4 1))
                (("2" (expand "max")
                  (("2" (lemma "exp_strict_increasing")
                    (("2" (expand "strict_increasing?")
                      (("2" (inst - "x!1" "0")
                        (("2" (rewrite "exp_0")
                          (("2" (assertnil)))))))))))))))
             ("2" (hide 2)
              (("2" (skosimp)
                (("2" (inst - "n!2")
                  (("2" (flatten)
                    (("2" (rewrite "expt_plus" 1)
                      (("2" (rewrite "expt_x1" 1)
                        (("2"
                          (lemma "both_sides_times_neg_lt1"
                           ("nz" "x!1" "y" "0" "x" "x!1^(2*n!2)"))
                          (("1"
                            (lemma "both_sides_times_neg_le1"
                             ("nz" "x!1" "x" "1" "y" "x!1^(2*n!2)"))
                            (("1" (assertnil)))
                           ("2" (assertnil)))))))))))))))))
           ("2" (hide 2)
            (("2" (skosimp)
              (("2" (rewrite "expt_times" 1)
                (("2" (case "0 < x!1^2 & x!1^2<=1")
                  (("1" (flatten)
                    (("1" (lemma "expt_pos" ("i" "n!2" "px" "x!1^2"))
                      (("1" (expand "<=" -3)
                        (("1" (split -3)
                          (("1" (case-replace "n!2=0")
                            (("1" (rewrite "expt_x0")
                              (("1" (assertnil)))
                             ("2"
                              (lemma "both_sides_expt_pos_lt"
                               ("px" "x!1^2" "py" "1" "pm" "n!2"))
                              (("1"
                                (rewrite "expt_1i")
                                (("1" (assertnil)))
                               ("2" (assertnil)))))
                           ("2" (replace -1)
                            (("2" (rewrite "expt_1i")
                              (("2" (assertnil)))))))))
                       ("2" (assertnil)))))
                   ("2" (hide 2)
                    (("2"
                      (lemma "negreal_times_negreal_is_posreal"
                       ("nx" "x!1" "ny" "x!1"))
                      (("1" (lemma "le_times_le_neg")
                        (("1" (inst - "x!1" "x!1" "-1" "-1")
                          (("1" (expand "^")
                            (("1" (expand "expt")
                              (("1"
                                (expand "expt")
                                (("1"
                                  (expand "expt")
                                  (("1" (assertnil)))))))))
                           ("2" (assertnil)))))
                       ("2" (assertnil))))))))))))))))))))
    nil)
   nil nil)
  (exp_neg_le1_bounds-1 nil 3295528895
   ("" (expand "exp_neg_le1_lb")
    (("" (expand "exp_neg_le1_ub")
      (("" (skosimp)
        (("" (case "FORALL (n:nat): 0 < x!1^(2*n) & x!1^(2*n) <= 1")
          (("1"
            (case "FORALL (n:nat): -1 <= x!1^(2*n+1) & x!1^(2*n+1) < 0")
            (("1" (case "max(exp(x!1), 1) = 1")
              (("1"
                (case "FORALL (n,m:posnat): n < m => abs(x!1)^m/factorial(m) < abs(x!1)^n/factorial(n)")
                (("1"
                  (case-replace
                   "exp_series_n(x!1, 1 + 2 * n!1) < exp(x!1)")
                  (("1" (lemma "exp_series" ("x" "x!1" "n" "1+2*n!1"))
                    (("1" (expand "abs" -1 1)
                      (("1" (assert)
                        (("1" (replace -4)
                          (("1" (hide -2)
                            (("1" (expand "exp_series_n")
                              (("1"
                                (expand "sigma" -1 1)
                                (("1"
                                  (name-replace
                                   "RHS"
                                   "sigma(0, 2 * n!1,
             LAMBDA (nn: nat):
               IF nn = 0 THEN 1 ELSE x!1 ^ nn / factorial(nn) ENDIF)")
                                  (("1"
                                    (case
                                     "(x!1^(1+2*n!1))/factorial(1+2*n!1) + abs(x!1)^(2+2*n!1)/factorial(2+2*n!1) < 0")
                                    (("1" (assertnil nil)
                                     ("2"
                                      (inst -2 "1+2*n!1" "2+2*n!1")
                                      (("2"
                                        (assert)
                                        (("2"
                                          (case-replace
                                           "abs(x!1) ^ (1 + 2 * n!1) = -(x!1^(1+2*n!1))")
                                          (("1" (assertnil nil)
                                           ("2"
                                            (hide 2 3 -1 -3)
                                            (("2"
                                              (hide -1 -2 -3)
                                              (("2"
                                                (rewrite "expt_plus")
                                                (("1"
                                                  (rewrite "expt_plus")
                                                  (("1"
                                                    (rewrite "expt_x1")
                                                    (("1"
                                                      (rewrite
                                                       "expt_x1")
                                                      (("1"
                                                        (rewrite
                                                         "expt_times")
                                                        (("1"
                                                          (rewrite
                                                           "expt_times")
                                                          (("1"
                                                            (expand
                                                             "abs")
                                                            (("1"
                                                              (case-replace
                                                               "(-x!1) ^ 2=x!1 ^ 2")
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil)
                                                               ("2"
                                                                (hide
                                                                 2)
                                                                (("2"
                                                                  (expand
                                                                   "^")
                                                                  (("2"
                                                                    (expand
                                                                     "expt")
                                                                    (("2"
                                                                      (expand
                                                                       "expt")
                                                                      (("2"
                                                                        (expand
                                                                         "expt")
                                                                        (("2"
                                                                          (assert)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (expand
                                                           "abs")
                                                          (("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (expand "abs")
                                                  (("2"
                                                    (assert)
                                                    nil
                                                    nil))
--> --------------------

--> maximum size reached

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

¤ Dauer der Verarbeitung: 0.88 Sekunden  (vorverarbeitet)  ¤





Download des
Quellennavigators
Download des
sprechenden Kalenders

Eigene Datei ansehen




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