Quellcode-Bibliothek

^© Kompilation durch diese Firma

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

Datei: atan_values.prf Sprache: Lisp

Original von: PVS^©

(exp_series
(exp_estimate_TCC1 0
  (exp_estimate_TCC1-1 nil 3302449689
   ("" (skosimp*) (("" (assert) nil nil)) nil)
   ((real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   shostak))
(exp_estimate_TCC2 0
  (exp_estimate_TCC2-1 nil 3507030466 ("" (subtype-tcc) nil nil)
   ((/= const-decl "boolean" notequal nil)) nil))
(exp_taylors_TCC1 0
  (exp_taylors_TCC1-1 nil 3302449689
   ("" (skosimp*) (("" (assert) nil nil)) nil)
   ((nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   shostak))
(exp_taylors 0
  (exp_taylors-1 nil 3302448557
   ("" (skosimp*)
    (("" (lemma "Taylors" ("f" "exp" "n" "n!1" "aa" "0" "bb" "x!1"))
      ((""
        (lemma "sigma_eq[nat]"
         ("low" "1" "high" "n!1" "F" "LAMBDA (nn:nat):
                        IF nn > n!1 THEN 0
                        ELSIF nn = 0 THEN exp(0)
                        ELSE nderiv(nn, exp)(0) * (x!1 - 0) ^ nn / factorial(nn)
                        ENDIF" "G"
          "LAMBDA (nn: nat): x!1 ^ nn / factorial(nn)"))
        (("1" (assert)
          (("1" (expand "exp_estimate")
            (("1" (split -1)
              (("1" (rewrite "sigma_first" -2)
                (("1" (replace -1)
                  (("1" (hide -1)
                    (("1" (lemma "nderiv_exp" ("n" "n!1+1"))
                      (("1" (flatten) (("1" (assert) nil nil)) nil))
                      nil))
                    nil))
                  nil)
                 ("2" (case-replace "n!1 = 0")
                  (("1" (assert)
                    (("1" (expand "sigma")
                      (("1" (split -3)
                        (("1" (lemma "nderiv_exp")
                          (("1" (inst?)
                            (("1" (flatten)
                              (("1"
                                (replace -2)
                                (("1" (propax) nil nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (lemma "nderiv_exp")
                          (("2" (inst?) (("2" (flatten) nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (assert) nil nil))
                  nil))
                nil)
               ("2" (skosimp*)
                (("2" (hide 2)
                  (("2" (hide -1)
                    (("2" (lemma "nderiv_exp")
                      (("2" (inst?)
                        (("2" (flatten)
                          (("2" (replace -2) (("2" (assert) nil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (skosimp*)
          (("2" (assert)
            (("2" (hide - 4)
              (("2" (lemma "nderiv_exp")
                (("2" (inst?) (("2" (flatten) nil nil)) nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((sigma_eq formula-decl nil sigma "reals/")
    (sigma_first formula-decl nil sigma "reals/")
    (sigma def-decl "real" sigma "reals/")
    (exp_0 formula-decl nil ln_exp nil)
    (ln const-decl "real" ln_exp nil)
    (exp const-decl "{py | x = ln(py)}" ln_exp nil))
   nil))
(exp_taylors_err_TCC1 0
  (exp_taylors_err_TCC1-1 nil 3302449689
   ("" (skosimp*) (("" (assert) nil nil)) nil)
   ((nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   shostak))
(exp_taylors_err 0
  (exp_taylors_err-2 nil 3302449661
   ("" (skosimp*)
    (("" (lemma "exp_taylors" ("x" "x!1" "n" "n!1"))
      (("" (skosimp*)
        (("" (typepred "c!1")
          (("" (lemma "trichotomy" ("x" "x!1"))
            ((""
              (case "exp(x!1) - exp_estimate(x!1, n!1) = exp(c!1) * x!1 ^ (n!1 + 1) / factorial(n!1 + 1)")
              (("1" (replace -1)
                (("1" (rewrite "abs_div" 1)
                  (("1" (expand "abs" 1 2)
                    (("1"
                      (lemma "both_sides_div_pos_le1"
                       ("x" "abs(exp(c!1) * x!1 ^ (1 + n!1))" "y"
                        "max(exp(x!1),1) * x!1 ^ (1 + n!1)" "pz"
                        "factorial(1 + n!1)"))
                      (("1" (hide -1 -2 -7)
                        (("1" (rewrite "abs_mult")
                          (("1" (expand "abs" 1 1)
                            (("1" (case "exp(c!1)<=max(exp(x!1),1)")
                              (("1"
                                (split -2)
                                (("1"
                                  (lemma
                                   "expt_pos"
                                   ("px" "x!1" "i" "1+n!1"))
                                  (("1"
                                    (expand "abs" 1)
                                    (("1"
                                      (lemma "exp_strict_increasing")
                                      (("1"
                                        (expand "strict_increasing?")
                                        (("1"
                                          (inst-cp - "0" "c!1")
                                          (("1"
                                            (inst - "c!1" "x!1")
                                            (("1"
                                              (rewrite "exp_0")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (flatten -6)
                                                  (("1"
                                                    (expand "max")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (lemma
                                                         "both_sides_times_pos_lt1"
                                                         ("x"
                                                          "exp(c!1)"
                                                          "y"
                                                          "exp(x!1)"
                                                          "pz"
                                                          "x!1^(1+n!1)"))
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (lemma
                                                             "both_sides_div_pos_lt1"
                                                             ("x"
                                                              "exp(c!1) * x!1 ^ (1 + n!1)"
                                                              "y"
                                                              "exp(x!1) * x!1 ^ (1 + n!1)"
                                                              "pz"
                                                              "factorial(1+n!1)"))
                                                            (("1"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2" (assert) nil nil))
                                  nil)
                                 ("2"
                                  (replace -1)
                                  (("2"
                                    (replace -5)
                                    (("2"
                                      (rewrite "exp_0")
                                      (("2"
                                        (expand "max")
                                        (("2"
                                          (expand "^")
                                          (("2"
                                            (expand "expt")
                                            (("2"
                                              (expand "abs")
                                              (("2" (assert) nil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("3"
                                  (lemma "exp_strict_increasing")
                                  (("3"
                                    (expand "strict_increasing?")
                                    (("3"
                                      (assert)
                                      (("3"
                                        (hide -4 -6)
                                        (("3"
                                          (flatten -4)
                                          (("3"
                                            (inst-cp - "x!1" "c!1")
                                            (("3"
                                              (inst - "c!1" "0")
                                              (("3"
                                                (rewrite "exp_0")
                                                (("3"
                                                  (expand "max")
                                                  (("3"
                                                    (assert)
                                                    (("3"
                                                      (typepred
                                                       "exp(c!1)")
                                                      (("3"
                                                        (hide -1 -3)
                                                        (("3"
                                                          (case
                                                           "abs(x!1 ^ (1 + n!1)) = abs(x!1) ^ (1 + n!1)")
                                                          (("1"
                                                            (lemma
                                                             "posreal_div_posreal_is_posreal"
                                                             ("px"
                                                              "abs(x!1) ^ (1 + n!1)"
                                                              "py"
                                                              "factorial(1 + n!1)"))
                                                            (("1"
                                                              (lemma
                                                               "both_sides_times_pos_le1"
                                                               ("x"
                                                                "exp(c!1)"
                                                                "y"
                                                                "1"
                                                                "pz"
                                                                "abs(x!1) ^ (1 + n!1) / factorial(1 + n!1)"))
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil)
                                                               ("2"
                                                                (propax)
                                                                nil
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (hide 2)
                                                              (("2"
                                                                (lemma
                                                                 "expt_pos"
                                                                 ("px"
                                                                  "abs(x!1)"
                                                                  "i"
                                                                  "1+n!1"))
                                                                (("1"
                                                                  (propax)
                                                                  nil
                                                                  nil)
                                                                 ("2"
                                                                  (hide
                                                                   2)
                                                                  (("2"
                                                                    (expand
                                                                     "abs")
                                                                    (("2"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (hide 2)
                                                            (("2"
                                                              (case
                                                               "FORALL (n:nat): abs(x!1^n) = abs(x!1)^n")
                                                              (("1"
                                                                (inst
                                                                 -
                                                                 "1+n!1")
                                                                nil
                                                                nil)
                                                               ("2"
                                                                (hide-all-but
                                                                 (-4
                                                                  1))
                                                                (("2"
                                                                  (induct
                                                                   "n")
                                                                  (("1"
                                                                    (rewrite
                                                                     "expt_x0")
                                                                    (("1"
                                                                      (rewrite
                                                                       "expt_x0")
                                                                      (("1"
                                                                        (expand
                                                                         "abs")
                                                                        (("1"
                                                                          (propax)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (skosimp*)
                                                                    (("2"
                                                                      (expand
                                                                       "^")
                                                                      (("2"
                                                                        (expand
                                                                         "expt"
                                                                         1)
                                                                        (("2"
                                                                          (rewrite
                                                                           "abs_mult"
                                                                           1)
                                                                          (("2"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide 2)
                                (("2"
                                  (expand "max")
                                  (("2"
                                    (lemma "exp_strict_increasing")
                                    (("2"
                                      (expand "strict_increasing?")
                                      (("2"
                                        (split -2)
                                        (("1"
                                          (assert)
                                          (("1"
                                            (flatten -3)
                                            (("1"
                                              (inst-cp - "0" "c!1")
                                              (("1"
                                                (inst - "c!1" "x!1")
                                                (("1"
                                                  (rewrite "exp_0")
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (assert)
                                          (("2"
                                            (replace -1)
                                            (("2"
                                              (replace -3)
                                              (("2"
                                                (rewrite "exp_0")
                                                (("2"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("3"
                                          (assert)
                                          (("3"
                                            (flatten -4)
                                            (("3"
                                              (inst-cp - "x!1" "c!1")
                                              (("3"
                                                (inst - "c!1" "0")
                                                (("3"
                                                  (rewrite "exp_0")
                                                  (("3"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (assert) nil nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((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_taylors formula-decl nil exp_series nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (< const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (between type-eq-decl nil taylor_help nil)
    (factorial def-decl "posnat" factorial "ints/")
    (posnat nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (^ const-decl "real" exponentiation nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/= const-decl "boolean" notequal nil)
    (exp_estimate const-decl "real" exp_series nil)
    (exp const-decl "{py | x = ln(py)}" ln_exp nil)
    (ln const-decl "real" ln_exp nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (abs_div formula-decl nil real_props nil)
    (nzint_abs_is_pos application-judgement "{j: posint | j >= i}"
     real_defs nil)
    (nnreal_div_posreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (both_sides_div_pos_le1 formula-decl nil real_props nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (abs_mult formula-decl nil real_props nil)
    (nonzero_abs_is_pos application-judgement "{y: posreal | y >= x}"
     real_defs nil)
    (<= const-decl "bool" reals nil)
    (both_sides_times_pos_le1 formula-decl nil real_props nil)
    (posreal_div_posreal_is_posreal judgement-tcc nil real_types nil)
    (pred type-eq-decl nil defined_types nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (expt_x0 formula-decl nil exponentiation nil)
    (nnreal_expt application-judgement "nnreal" exponentiation nil)
    (nat_exp application-judgement "nat" exponentiation nil)
    (nat_expt application-judgement "nat" exponentiation nil)
    (nnrat_div_posrat_is_nnrat application-judgement "nonneg_rat"
     rationals nil)
    (expt def-decl "real" exponentiation nil)
    (int_abs_is_nonneg application-judgement "{j: nonneg_int | j >= i}"
     real_defs nil)
    (expt_pos formula-decl nil exponentiation nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (exp_strict_increasing formula-decl nil ln_exp nil)
    (exp_0 formula-decl nil ln_exp nil)
    (both_sides_div_pos_lt1 formula-decl nil real_props nil)
    (both_sides_times_pos_lt1 formula-decl nil real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (strict_increasing? const-decl "bool" real_fun_preds "reals/")
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         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)
    (real_times_real_is_real application-judgement "real" reals nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (trichotomy formula-decl nil real_axioms nil)
    (real_minus_real_is_real application-judgement "real" reals nil))
   nil)
  (exp_taylors_err-1 nil 3302449625
   ("" (skosimp*)
    (("" (lemma "exp_taylors" ("x" "x!1" "n" "n!1"))
      (("" (skosimp*)
        (("" (typepred "c!1")
          (("" (lemma "trichotomy" ("x" "x!1"))
            ((""
              (case "exp(x!1) - exp_series_n(x!1, n!1) = exp(c!1) * x!1 ^ (n!1 + 1) / factorial(n!1 + 1)")
              (("1" (replace -1)
                (("1" (rewrite "abs_div" 1)
                  (("1" (expand "abs" 1 2)
                    (("1"
                      (lemma "both_sides_div_pos_le1"
                       ("x" "abs(exp(c!1) * x!1 ^ (1 + n!1))" "y"
                        "max(exp(x!1),1) * x!1 ^ (1 + n!1)" "pz"
                        "factorial(1 + n!1)"))
                      (("1" (hide -1 -2 -7)
                        (("1" (rewrite "abs_mult")
                          (("1" (expand "abs" 1 1)
                            (("1" (case "exp(c!1)<=max(exp(x!1),1)")
                              (("1"
                                (split -2)
                                (("1"
                                  (lemma
                                   "expt_pos"
                                   ("px" "x!1" "i" "1+n!1"))
                                  (("1"
                                    (expand "abs" 1)
                                    (("1"
                                      (lemma "exp_strict_increasing")
                                      (("1"
                                        (expand "strict_increasing?")
                                        (("1"
                                          (inst-cp - "0" "c!1")
                                          (("1"
                                            (inst - "c!1" "x!1")
                                            (("1"
                                              (rewrite "exp_0")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (flatten -6)
                                                  (("1"
                                                    (expand "max")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (lemma
                                                         "both_sides_times_pos_lt1"
                                                         ("x"
                                                          "exp(c!1)"
                                                          "y"
                                                          "exp(x!1)"
                                                          "pz"
                                                          "x!1^(1+n!1)"))
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (lemma
                                                             "both_sides_div_pos_lt1"
                                                             ("x"
                                                              "exp(c!1) * x!1 ^ (1 + n!1)"
                                                              "y"
                                                              "exp(x!1) * x!1 ^ (1 + n!1)"
                                                              "pz"
                                                              "factorial(1+n!1)"))
                                                            (("1"
                                                              (assert)
                                                              nil)))))))))))))))))))))))))))
                                   ("2" (assert) nil)))
                                 ("2"
                                  (replace -1)
                                  (("2"
                                    (replace -5)
                                    (("2"
                                      (rewrite "exp_0")
                                      (("2"
                                        (expand "max")
                                        (("2"
                                          (expand "^")
                                          (("2"
                                            (expand "expt")
                                            (("2"
                                              (expand "abs")
                                              (("2"
                                                (assert)
                                                nil)))))))))))))))
                                 ("3"
                                  (lemma "exp_strict_increasing")
                                  (("3"
                                    (expand "strict_increasing?")
                                    (("3"
                                      (assert)
                                      (("3"
                                        (hide -4 -6)
                                        (("3"
                                          (flatten -4)
                                          (("3"
                                            (inst-cp - "x!1" "c!1")
                                            (("3"
                                              (inst - "c!1" "0")
                                              (("3"
                                                (rewrite "exp_0")
                                                (("3"
                                                  (expand "max")
                                                  (("3"
                                                    (assert)
                                                    (("3"
                                                      (typepred
                                                       "exp(c!1)")
                                                      (("3"
                                                        (hide -1 -3)
                                                        (("3"
                                                          (case
                                                           "abs(x!1 ^ (1 + n!1)) = abs(x!1) ^ (1 + n!1)")
                                                          (("1"
                                                            (lemma
                                                             "posreal_div_posreal_is_posreal"
                                                             ("px"
                                                              "abs(x!1) ^ (1 + n!1)"
                                                              "py"
                                                              "factorial(1 + n!1)"))
                                                            (("1"
                                                              (lemma
                                                               "both_sides_times_pos_le1"
                                                               ("x"
                                                                "exp(c!1)"
                                                                "y"
                                                                "1"
                                                                "pz"
                                                                "abs(x!1) ^ (1 + n!1) / factorial(1 + n!1)"))
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (replace
                                                                   -3
                                                                   1)
                                                                  (("1"
                                                                    (assert)
                                                                    nil)))))
                                                               ("2"
                                                                (propax)
                                                                nil)))
                                                             ("2"
                                                              (hide 2)
                                                              (("2"
                                                                (lemma
                                                                 "expt_pos"
                                                                 ("px"
                                                                  "abs(x!1)"
                                                                  "i"
                                                                  "1+n!1"))
                                                                (("1"
                                                                  (propax)
                                                                  nil)
                                                                 ("2"
                                                                  (hide
                                                                   2)
                                                                  (("2"
                                                                    (expand
                                                                     "abs")
                                                                    (("2"
                                                                      (assert)
                                                                      nil)))))))))))
                                                           ("2"
                                                            (hide 2)
                                                            (("2"
                                                              (case
                                                               "FORALL (n:nat): abs(x!1^n) = abs(x!1)^n")
                                                              (("1"
                                                                (inst
                                                                 -
                                                                 "1+n!1")
                                                                nil)
                                                               ("2"
                                                                (hide-all-but
                                                                 (-4
                                                                  1))
                                                                (("2"
                                                                  (induct
                                                                   "n")
                                                                  (("1"
                                                                    (rewrite
                                                                     "expt_x0")
                                                                    (("1"
                                                                      (rewrite
                                                                       "expt_x0")
                                                                      (("1"
                                                                        (expand
                                                                         "abs")
                                                                        (("1"
                                                                          (propax)
                                                                          nil)))))))
                                                                   ("2"
                                                                    (skosimp*)
                                                                    (("2"
                                                                      (expand
                                                                       "^")
                                                                      (("2"
                                                                        (expand
                                                                         "expt"
                                                                         1)
                                                                        (("2"
                                                                          (rewrite
                                                                           "abs_mult"
                                                                           1)
                                                                          (("2"
                                                                            (assert)
                                                                            nil)))))))))))))))))))))))))))))))))))))))))))))
                               ("2"
                                (hide 2)
                                (("2"
                                  (expand "max")
                                  (("2"
                                    (lemma "exp_strict_increasing")
                                    (("2"
                                      (expand "strict_increasing?")
                                      (("2"
                                        (split -2)
                                        (("1"
                                          (assert)
                                          (("1"
                                            (flatten -3)
                                            (("1"
                                              (inst-cp - "0" "c!1")
                                              (("1"
                                                (inst - "c!1" "x!1")
                                                (("1"
                                                  (rewrite "exp_0")
                                                  (("1"
                                                    (assert)
                                                    nil)))))))))))
                                         ("2"
                                          (assert)
                                          (("2"
                                            (replace -1)
                                            (("2"
                                              (replace -3)
                                              (("2"
                                                (rewrite "exp_0")
                                                (("2"
                                                  (assert)
                                                  nil)))))))))
                                         ("3"
                                          (assert)
                                          (("3"
                                            (flatten -4)
                                            (("3"
                                              (inst-cp - "x!1" "c!1")
                                              (("3"
                                                (inst - "c!1" "0")
                                                (("3"
                                                  (rewrite "exp_0")
                                                  (("3"
                                                    (assert)
                                                    nil)))))))))))))))))))))))))))))))))))))
               ("2" (assert) nil))))))))))))
    nil)
   nil nil)))

¤ Dauer der Verarbeitung: 0.145 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.