products/sources/formale sprachen/PVS/interval_arith image not shown  

Quellcode-Bibliothek

© Kompilation durch diese Firma

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

Datei: interval_trig.prf   Sprache: Lisp

Original von: PVS©

(interval_trig
 (cos_error_pi_lbn_bound 0
  (cos_error_pi_lbn_bound-1 nil 3554219250
   ("" (expand "cos_term")
    (("" (case "FORALL (kk:nat): even?(kk) IMPLIES (-1)^kk = 1")
      (("1" (skeep)
        (("1" (inst-cp - "2+2*n")
          (("1" (hide -1)
            (("1" (split -)
              (("1" (replaces -1)
                (("1" (assert)
                  (("1" (expand "abs")
                    (("1" (case "pi_lbn(n)^(4+4*n) < 3.2^(4+4*n)")
                      (("1" (mult-by -1 "1/factorial(4+4*n)")
                        (("1" (assertnil nil)) nil)
                       ("2" (hide 2)
                        (("2" (lemma "both_sides_expt_pos_lt_aux")
                          (("2" (inst - "3+4*n" "pi_lbn(n)" "3.2")
                            (("2" (assert)
                              (("2"
                                (expand "^")
                                (("2"
                                  (assert)
                                  (("2"
                                    (hide 2)
                                    (("2"
                                      (lemma "pi_bounds")
                                      (("2"
                                        (inst-cp - "n")
                                        (("2"
                                          (inst - "3")
                                          (("2"
                                            (eval-expr "pi_ubn(3)")
                                            (("2"
                                              (assert)
                                              (("2" (ground) nil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (hide 2)
                (("2" (expand "even?")
                  (("2" (inst + "1+n") (("2" (assertnil nil)) nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (hide 2)
        (("2" (skeep)
          (("2" (expand "even?")
            (("2" (skosimp*)
              (("2" (replace -1)
                (("2" (lemma "expt_times")
                  (("2" (inst?)
                    (("2" (case "(-1)^2 = 1")
                      (("1" (replaces -1)
                        (("1" (replaces -1)
                          (("1" (case "FORALL (jjj:nat): 1^jjj = 1")
                            (("1" (inst?) (("1" (assertnil nil)) nil)
                             ("2" (induct "jjj")
                              (("1"
                                (hide-all-but 1)
                                (("1" (grind) nil nil))
                                nil)
                               ("2"
                                (skeep)
                                (("2"
                                  (expand "^")
                                  (("2"
                                    (expand "expt" 1)
                                    (("2" (assertnil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (hide-all-but 1) (("2" (grind) nil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((- const-decl "[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 "[T, T -> boolean]" equalities nil)
    (even? const-decl "bool" integers nil)
    (IMPLIES 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)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (even_plus_even_is_even application-judgement "even_int" integers
     nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (posrat_div_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (pi_lb_pos application-judgement "posreal" atan_approx "trig_fnd/")
    (nonzero_abs_is_pos application-judgement "{y: posreal | y >= x}"
     real_defs nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (< const-decl "bool" reals nil)
    (pi_lbn const-decl "real" atan_approx "trig_fnd/")
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (posrat_times_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (factorial def-decl "posnat" factorial "ints/")
    (posnat nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers 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)
    (both_sides_times_pos_lt1 formula-decl nil real_props nil)
    (both_sides_expt_pos_lt_aux formula-decl nil exponentiation nil)
    (posrat_expt application-judgement "posrat" exponentiation nil)
    (odd_plus_odd_is_even application-judgement "even_int" integers
     nil)
    (posreal_expt application-judgement "posreal" exponentiation nil)
    (nzreal_expt application-judgement "nzreal" exponentiation nil)
    (pi_bounds formula-decl nil atan_approx "trig_fnd/")
    (pi_bound name-judgement "{r: posreal | pi_lb < r AND r < pi_ub}"
     atan_approx "trig_fnd/")
    (pi_ubn const-decl "real" atan_approx "trig_fnd/")
    (pi_ub_pos application-judgement "posreal" atan_approx "trig_fnd/")
    (bijective? const-decl "bool" functions nil)
    (id const-decl "(bijective?[T, T])" identity nil)
    (TRUE const-decl "bool" booleans nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (posreal_times_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (posreal_div_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (nzreal_div_nzreal_is_nzreal application-judgement "nzreal"
     real_types nil)
    (expt_times formula-decl nil exponentiation nil)
    (pred type-eq-decl nil defined_types nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (expt def-decl "real" exponentiation nil)
    (posnat_expt application-judgement "posnat" exponentiation nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (j!1 skolem-const-decl "int" interval_trig nil)
    (posint_exp application-judgement "posint" exponentiation nil)
    (nzint_times_nzint_is_nzint application-judgement "nzint" integers
     nil)
    (nzrat_div_nzrat_is_nzrat application-judgement "nzrat" rationals
     nil)
    (int_expt application-judgement "int" exponentiation nil)
    (nzreal nonempty-type-eq-decl nil reals nil)
    (cos_term const-decl "real" trig_approx "trig_fnd/")
    (posrat_exp application-judgement "posrat" exponentiation nil)
    (nnrat_exp application-judgement "nnrat" exponentiation nil)
    (nzreal_times_nzreal_is_nzreal application-judgement "nzreal"
     real_types nil)
    (posreal_exp application-judgement "posreal" exponentiation nil)
    (nzreal_exp application-judgement "nzreal" exponentiation nil)
    (int_exp application-judgement "int" exponentiation 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))
 (Pi_TCC1 0
  (Pi_TCC1-1 nil 3318076124
   ("" (skeep)
    (("" (expand "Pos?")
      (("" (expand "Gt")
        (("" (expand "[||]")
          (("" (split) (("1" (assertnil nil) ("2" (assertnil nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((Pos? const-decl "bool" interval nil)
    ([\|\|] const-decl "Interval" interval nil)
    (pi_ub_pos application-judgement "posreal" atan_approx "trig_fnd/")
    (pi_lb_pos application-judgement "posreal" atan_approx "trig_fnd/")
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (Gt const-decl "bool" interval nil))
   nil))
 (Cos_fundamental 0
  (Cos_fundamental-3 nil 3554808246
   ("" (skeep)
    (("" (expand "<<")
      (("" (flatten)
        (("" (split)
          (("1" (expand "Cos")
            (("1" (lift-if)
              (("1" (lift-if)
                (("1" (lift-if)
                  (("1" (lift-if)
                    (("1" (assert)
                      (("1" (lift-if)
                        (("1" (assert)
                          (("1" (ground)
                            (("1" (expand "cos_0_pi")
                              (("1"
                                (expand "[||]")
                                (("1"
                                  (lemma "cos_lb_nn_strict_decreasing")
                                  (("1"
                                    (inst - "n")
                                    (("1"
                                      (expand "strict_decreasing?")
                                      (("1"
                                        (inst - "ub(X)" "ub(Y)")
                                        (("1" (assertnil nil)
                                         ("2"
                                          (case "Proper?(Y)")
                                          (("1"
                                            (hide-all-but (-1 -3 1))
                                            (("1"
                                              (expand "Proper?")
                                              (("1"
                                                (lemma "pi_bounds")
                                                (("1"
                                                  (inst - "n")
                                                  (("1"
                                                    (lemma
                                                     "pi_lb_est_le")
                                                    (("1"
                                                      (inst - "n")
                                                      (("1"
                                                        (expand "<<")
                                                        (("1"
                                                          (ground)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (expand "Proper?")
                                            (("2" (ground) nil nil))
                                            nil))
                                          nil)
                                         ("3"
                                          (hide-all-but (-1 -3 1))
                                          (("3"
                                            (lemma "pi_lb_est_le")
                                            (("3"
                                              (inst - "n")
                                              (("3"
                                                (expand "Proper?")
                                                (("3"
                                                  (expand "<<")
                                                  (("3"
                                                    (ground)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (case "NOT X = [|0,0|]")
                              (("1"
                                (hide 2)
                                (("1"
                                  (hide 2)
                                  (("1"
                                    (expand "Proper?")
                                    (("1"
                                      (expand "[||]")
                                      (("1"
                                        (expand "<<")
                                        (("1"
                                          (decompose-equality +)
                                          (("1"
                                            (grind
                                             :exclude
                                             "pi_lb_est")
                                            nil
                                            nil)
                                           ("2"
                                            (grind
                                             :exclude
                                             "pi_lb_est")
                                            nil
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (replace -1)
                                (("2"
                                  (hide-all-but 2)
                                  (("2"
                                    (grind :exclude "pi_lb_est")
                                    nil
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("3" (hide (-3 1 2))
                              (("3"
                                (grind :exclude "pi_lb_est")
                                nil
                                nil))
                              nil)
                             ("4" (hide-all-but (- 4))
                              (("4"
                                (grind :exclude "pi_lb_est")
                                nil
                                nil))
                              nil)
                             ("5" (case "NOT X = [|0,0|]")
                              (("1"
                                (hide-all-but (- 1))
                                (("1"
                                  (decompose-equality +)
                                  (("1"
                                    (grind :exclude "pi_lbn")
                                    nil
                                    nil)
                                   ("2"
                                    (grind :exclude "pi_lbn")
                                    nil
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (replace -1)
                                (("2"
                                  (expand "Neg")
                                  (("2"
                                    (expand "[||]" 1)
                                    (("2"
                                      (expand "cos_0_pi" 1 1)
                                      (("2"
                                        (expand "[||]" 1)
                                        (("2"
                                          (expand "cos_0_pi")
                                          (("2"
                                            (expand "[||]" 1)
                                            (("2"
                                              (expand "cos_lb" + 2)
                                              (("2"
                                                (lemma "cos_approx_a0")
                                                (("2"
                                                  (inst?)
                                                  (("2"
                                                    (replace -1)
                                                    (("2"
                                                      (hide -1)
                                                      (("2"
                                                        (assert)
                                                        (("2"
                                                          (lemma
                                                           "cos_bounds")
                                                          (("2"
                                                            (inst?)
                                                            (("2"
                                                              (ground)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("6" (expand "Neg")
                              (("6"
                                (expand "cos_0_pi")
                                (("6"
                                  (expand "[||]")
                                  (("6"
                                    (rewrite "cos_lb_neg")
                                    (("6"
                                      (rewrite "cos_lb_neg")
                                      (("6"
                                        (lemma
                                         "cos_lb_np_strict_increasing")
                                        (("6"
                                          (inst - "n")
                                          (("6"
                                            (expand
                                             "strict_increasing?")
                                            (("6"
                                              (inst - "lb(Y)" "lb(X)")
                                              (("1" (assertnil nil)
                                               ("2"
                                                (assert)
                                                (("2"
                                                  (expand "<<")
                                                  (("2"
                                                    (flatten)
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("3"
                                                (assert)
                                                (("3"
                                                  (lemma
                                                   "pi_lb_est_le")
                                                  (("3"
                                                    (inst - "n")
                                                    (("3"
                                                      (lemma
                                                       "pi_bounds")
                                                      (("3"
                                                        (inst?)
                                                        (("3"
                                                          (expand "<<")
                                                          (("3"
                                                            (ground)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("7" (hide-all-but (- 2))
                              (("7" (grind :exclude "pi_lbn"nil nil))
                              nil)
                             ("8" (hide-all-but (- 3))
                              (("8" (grind :exclude "pi_lbn"nil nil))
                              nil)
                             ("9" (expand "cos_0_pi")
                              (("9"
                                (expand "cos_npi2_pi2")
                                (("9"
                                  (expand "[||]" 1)
                                  (("9"
                                    (lemma
                                     "cos_lb_nn_strict_decreasing")
                                    (("9"
                                      (inst - "n")
                                      (("9"
                                        (expand "strict_decreasing?")
                                        (("9"
                                          (inst - "ub(X)" "ub(Y)")
                                          (("1" (assertnil nil)
                                           ("2"
                                            (expand "<<")
                                            (("2"
                                              (expand "[||]")
                                              (("2"
                                                (lemma "pi_bounds")
                                                (("2"
                                                  (inst - "n")
                                                  (("2"
                                                    (ground)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("3"
                                            (expand "[||]")
                                            (("3"
                                              (expand "<<")
                                              (("3"
                                                (lemma "pi_bounds")
                                                (("3"
                                                  (inst - "n")
                                                  (("3"
                                                    (ground)
                                                    (("3"
                                                      (lemma
                                                       "pi_lb_est_le")
                                                      (("3"
                                                        (inst - "n")
                                                        (("3"
                                                          (ground)
                                                          (("3"
                                                            (expand
                                                             "Proper?")
                                                            (("3"
                                                              (ground)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("10" (expand "Neg")
                              (("10"
                                (expand "cos_0_pi")
                                (("10"
                                  (expand "cos_npi2_pi2")
                                  (("10"
                                    (expand "[||]")
                                    (("10"
                                      (rewrite "cos_lb_neg")
                                      (("10"
                                        (lemma
                                         "cos_lb_np_strict_increasing")
                                        (("10"
                                          (inst - "n")
                                          (("10"
                                            (expand
                                             "strict_increasing?")
                                            (("10"
                                              (inst - "lb(Y)" "lb(X)")
                                              (("1" (assertnil nil)
                                               ("2"
                                                (expand "<<")
                                                (("2"
                                                  (lemma "pi_bounds")
                                                  (("2"
                                                    (inst - "n")
                                                    (("2"
                                                      (expand
                                                       "Proper?")
                                                      (("2"
                                                        (ground)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("3"
                                                (expand "<<")
                                                (("3"
                                                  (expand "Proper?")
                                                  (("3"
                                                    (lemma "pi_bounds")
                                                    (("3"
                                                      (inst - "n")
                                                      (("3"
                                                        (ground)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("11" (expand "cos_npi2_pi2")
                              (("11"
                                (expand "[||]")
                                (("11"
                                  (expand "<<")
                                  (("11"
                                    (flatten)
                                    (("11"
                                      (expand "Proper?")
                                      (("11"
                                        (case "ub(X) <= 0")
                                        (("1" (assertnil nil)
                                         ("2"
                                          (assert)
                                          (("2"
                                            (lemma
                                             "cos_lb_np_strict_increasing")
                                            (("2"
                                              (inst - "n")
                                              (("2"
                                                (expand
                                                 "strict_increasing?")
                                                (("2"
                                                  (inst
                                                   -
                                                   "lb(Y)"
                                                   "lb(X)")
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (lemma
                                                       "cos_lb_nn_strict_decreasing")
                                                      (("2"
                                                        (inst - "n")
                                                        (("2"
                                                          (expand
                                                           "strict_decreasing?")
                                                          (("2"
                                                            (inst
                                                             -
                                                             "ub(X)"
                                                             "ub(Y)")
                                                            (("2"
                                                              (split -)
                                                              (("1"
                                                                (split
                                                                 -)
                                                                (("1"
                                                                  (expand
                                                                   "min")
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (lift-if)
                                                                      (("1"
                                                                        (lift-if)
                                                                        (("1"
                                                                          (lift-if)
                                                                          (("1"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (case
                                                                   "lb(Y) = lb(X)")
                                                                  (("1"
                                                                    (replace
                                                                     -1)
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (expand
                                                                         "min")
                                                                        (("1"
                                                                          (lift-if)
                                                                          (("1"
                                                                            (lift-if)
                                                                            (("1"
                                                                              (lift-if)
                                                                              (("1"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (assert)
                                                                (("2"
                                                                  (case
                                                                   "ub(X) = ub(Y)")
                                                                  (("1"
                                                                    (replace
                                                                     -1)
                                                                    (("1"
                                                                      (expand
                                                                       "min")
                                                                      (("1"
                                                                        (lift-if)
                                                                        (("1"
                                                                          (lift-if)
                                                                          (("1"
                                                                            (lift-if)
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      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)
                             ("12" (hide-all-but (- 1))
                              (("12"
                                (grind :exclude "pi_lb_est")
                                nil
                                nil))
                              nil)
                             ("13" (expand "cos_0_pi")
                              (("13"
                                (expand "[||]" 1)
                                (("13"
                                  (lemma "cos_lb_nn_strict_decreasing")
                                  (("13"
                                    (inst - "n")
                                    (("13"
                                      (expand "strict_decreasing?")
                                      (("13"
                                        (inst - "ub(X)" "pi_lbn(n)")
                                        (("1"
                                          (assert)
                                          (("1"
                                            (case
                                             "NOT cos_lb(pi_lbn(n), n) <=cos_lb(ub(X), n)")
                                            (("1"
                                              (assert)
                                              (("1"
                                                (lemma "pi_lb_est_le")
                                                (("1"
                                                  (inst - "n")
                                                  (("1"
                                                    (expand "<<")
                                                    (("1"
                                                      (ground)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (hide -2)
                                              (("2"
                                                (expand "cos_lb")
                                                (("2"
                                                  (lemma
                                                   "cos_approx_cos")
                                                  (("2"
                                                    (inst
                                                     -
                                                     "pi_lbn(n)"
                                                     "1+2*n")
                                                    (("2"
                                                      (lemma
                                                       "cos_error_pi_lbn_bound")
                                                      (("2"
                                                        (inst - "n")
                                                        (("2"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (lemma "pi_bounds")
                                          (("2"
                                            (inst?)
                                            (("2" (assertnil nil))
                                            nil))
                                          nil)
                                         ("3"
                                          (hide-all-but (-1 1 -2))
                                          (("3"
                                            (expand "Proper?")
                                            (("3"
                                              (lemma "pi_bounds")
                                              (("3"
                                                (inst - "n")
                                                (("3"
                                                  (lemma
                                                   "pi_lb_est_le")
                                                  (("3"
                                                    (inst - "n")
                                                    (("3"
                                                      (flatten)
                                                      (("3"
                                                        (expand "<<")
                                                        (("3"
                                                          (expand
                                                           "[||]")
                                                          (("3"
                                                            (ground)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("14" (expand "Neg")
                              (("14"
                                (expand "cos_0_pi")
                                (("14"
                                  (expand "[||]" 1)
                                  (("14"
                                    (expand "cos_lb")
                                    (("14"
                                      (lemma "cos_error_pi_lbn_bound")
                                      (("14"
                                        (inst - "n")
                                        (("14"
                                          (lemma
                                           "cos_lb_nn_strict_decreasing")
                                          (("14"
                                            (inst - "n")
                                            (("14"
                                              (expand
                                               "strict_decreasing?")
                                              (("14"
                                                (inst
                                                 -
                                                 "-lb(X)"
                                                 "pi_lbn(n)")
                                                (("1"
                                                  (case
                                                   "cos_lb(pi_lbn(n), n) <= cos_lb(-lb(X), n)")
                                                  (("1"
                                                    (hide -2)
                                                    (("1"
                                                      (expand "cos_lb")
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (lemma
                                                           "cos_approx_cos")
                                                          (("1"
                                                            (inst
                                                             -
                                                             "pi_lbn(n)"
                                                             "1+2*n")
                                                            (("1"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (assert)
                                                    (("2"
                                                      (expand "<<" -2)
                                                      (("2"
                                                        (expand
                                                         "[||]"
                                                         -)
                                                        (("2"
                                                          (lemma
                                                           "pi_lb_est_le")
                                                          (("2"
                                                            (inst
                                                             -
                                                             "n")
                                                            (("2"
                                                              (ground)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (lemma "pi_bounds")
                                                  (("2"
                                                    (inst?)
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("3"
                                                  (expand "<<" -)
                                                  (("3"
                                                    (expand "[||]" -)
                                                    (("3"
                                                      (flatten)
                                                      (("3"
                                                        (assert)
                                                        (("3"
                                                          (expand
                                                           "Proper?")
                                                          (("3"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("15" (expand "cos_npi2_pi2")
                              (("15"
                                (expand "[||]" 1)
                                (("15"
                                  (case
                                   "FORALL (xr:real): -pi_lbn(n)/2 <= xr AND xr <= pi_lbn(n)/2 IMPLIES -1 - (3.2 ^ (4 + 4 * n) / factorial(4 + 4 * n)) <= cos_lb(xr,n)")
                                  (("1"
                                    (inst-cp - "lb(X)")
                                    (("1"
                                      (inst - "ub(X)")
                                      (("1"
                                        (assert)
                                        (("1"
                                          (expand "Proper?")
                                          (("1"
                                            (expand "<<" -3)
                                            (("1"
                                              (lemma "pi_lb_est_le")
                                              (("1"
                                                (inst - "n")
                                                (("1"
                                                  (flatten)
                                                  (("1"
                                                    (expand "[||]" -)
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (expand "min")
                                                        (("1"
                                                          (lift-if)
                                                          (("1"
                                                            (ground)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (hide 2)
                                    (("2"
                                      (skeep)
                                      (("2"
                                        (case "xr <= 0")
                                        (("1"
                                          (lemma
                                           "cos_lb_np_strict_increasing")
                                          (("1"
                                            (inst - "n")
                                            (("1"
                                              (expand
                                               "strict_increasing?")
                                              (("1"
                                                (inst
                                                 -
                                                 "-pi_lbn(n)"
                                                 "xr")
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (lemma
                                                     "cos_approx_cos")
                                                    (("1"
                                                      (expand "cos_lb")
                                                      (("1"
                                                        (inst
                                                         -
                                                         "pi_lbn(n)"
                                                         "1+2*n")
                                                        (("1"
                                                          (lemma
                                                           "cos_error_pi_lbn_bound")
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (inst?)
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (rewrite
                                                                   "cos_approx_neg")
                                                                  (("1"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (assert)
                                                  (("2"
                                                    (lemma "pi_bounds")
                                                    (("2"
                                                      (inst - "n")
                                                      (("2"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("3"
                                                  (lemma "pi_bounds")
                                                  (("3"
                                                    (inst?)
                                                    (("3"
                                                      (assert)
                                                      (("3"
                                                        (ground)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (lemma
                                           "cos_lb_nn_strict_decreasing")
                                          (("2"
                                            (inst - "n")
                                            (("2"
                                              (expand
                                               "strict_decreasing?")
                                              (("2"
                                                (inst
                                                 -
                                                 "xr"
                                                 "pi_lbn(n)")
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (expand "cos_lb")
                                                    (("1"
                                                      (lemma
                                                       "cos_approx_cos")
                                                      (("1"
                                                        (inst
                                                         -
                                                         "pi_lbn(n)"
                                                         "1+2*n")
                                                        (("1"
                                                          (lemma
                                                           "cos_error_pi_lbn_bound")
                                                          (("1"
                                                            (inst?)
                                                            (("1"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
--> --------------------

--> maximum size reached

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

¤ Dauer der Verarbeitung: 0.44 Sekunden  (vorverarbeitet)  ¤





Druckansicht
unsichere Verbindung
Druckansicht
sprechenden Kalenders

in der Quellcodebibliothek suchen




Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.


Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.


Bot Zugriff