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

Quellcode-Bibliothek

© Kompilation durch diese Firma

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

Datei: hausdorff_convergence.pvs   Sprache: Lisp

Original von: PVS©

(fermats_little_theorem
 (prime_divides_choose_TCC1 0
  (prime_divides_choose_TCC1-1 nil 3564153926
   ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (> const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers 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)
    (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)
    (/= const-decl "boolean" notequal nil)
    (divides const-decl "bool" divides nil)
    (prime? const-decl "bool" primes "ints/"))
   nil))
 (prime_divides_choose 0
  (prime_divides_choose-1 nil 3564153932
   ("" (skeep)
    (("" (case "divides(p,factorial(p))")
      (("1" (case "divides(p,(factorial(np)*factorial(p-np))*C(p,np))")
        (("1" (lemma "prime_divides_prod")
          (("1" (inst - "p")
            (("1" (assert)
              (("1" (inst?)
                (("1" (assert)
                  (("1" (lemma "prime_divides_prod")
                    (("1" (hide -3)
                      (("1" (inst - "p")
                        (("1" (assert)
                          (("1" (inst?)
                            (("1" (assert)
                              (("1"
                                (lemma "prime_divides_factorial")
                                (("1"
                                  (inst?)
                                  (("1"
                                    (assert)
                                    (("1"
                                      (lemma "prime_divides_factorial")
                                      (("1"
                                        (inst - "np" "p")
                                        (("1" (assertnil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (hide 2)
          (("2" (expand "C" 1) (("2" (assertnil nil)) nil)) nil)
         ("3" (assertnil nil))
        nil)
       ("2" (lemma "prime_divides_factorial")
        (("2" (inst - "p" "p") (("2" (assertnil nil)) nil)) nil))
      nil))
    nil)
   ((factorial def-decl "posnat" factorial "ints/")
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (divides const-decl "bool" divides 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)
    (posrat_div_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (posrat_times_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (prime_divides_prod formula-decl nil primes "ints/")
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (prime_divides_factorial formula-decl nil primes "ints/")
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (<= const-decl "bool" reals nil)
    (C const-decl "posnat" binomial "reals/"))
   shostak))
 (Fermats_Little_TCC1 0
  (Fermats_Little_TCC1-1 nil 3411733664 ("" (subtype-tcc) nil nil)
   ((/= const-decl "boolean" notequal nil)
    (divides const-decl "bool" divides nil)
    (prime? const-decl "bool" primes "ints/"))
   nil))
 (Fermats_Little 0
  (Fermats_Little-1 nil 3411733696
   ("" (induct "a")
    (("1" (assert)
      (("1" (skeep)
        (("1" (expand "^")
          (("1" (expand "expt")
            (("1" (assert)
              (("1" (expand "eq_mod")
                (("1" (inst + "0") (("1" (assertnil nil)) nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil)
     ("2" (skeep)
      (("2" (name "A" "j")
        (("2" (replace -1)
          (("2" (assert)
            (("2" (skeep)
              (("2" (inst - "p")
                (("2" (assert)
                  (("2" (hide -1)
                    (("2" (lemma "binomial_theorem")
                      (("2" (inst?)
                        (("2" (replace -1)
                          (("2" (hide -1)
                            (("2" (invoke (name "FF" "%1") (! 1 1 3))
                              (("1"
                                (replace -1)
                                (("1"
                                  (expand "eq_mod")
                                  (("1"
                                    (case
                                     "EXISTS (GG:[nat->nat]): FORALL (ii:nat): 1<=ii AND ii<=p-1 IMPLIES p*GG(ii)=FF(ii)")
                                    (("1"
                                      (skeep -1)
                                      (("1"
                                        (lemma "sigma_split")
                                        (("1"
                                          (inst - "FF" _ _ _)
                                          (("1"
                                            (inst-cp - "p" "0" "0")
                                            (("1"
                                              (assert)
                                              (("1"
                                                (replace -2)
                                                (("1"
                                                  (expand "sigma" + 1)
                                                  (("1"
                                                    (expand
                                                     "sigma"
                                                     +
                                                     1)
                                                    (("1"
                                                      (expand "FF" + 1)
                                                      (("1"
                                                        (expand
                                                         "^"
                                                         +
                                                         1)
                                                        (("1"
                                                          (expand
                                                           "expt"
                                                           +)
                                                          (("1"
                                                            (inst
                                                             -
                                                             "p"
                                                             "1"
                                                             "p-1")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (replace
                                                                 -1)
                                                                (("1"
                                                                  (hide
                                                                   -1)
                                                                  (("1"
                                                                    (expand
                                                                     "sigma"
                                                                     +
                                                                     2)
                                                                    (("1"
                                                                      (expand
                                                                       "sigma"
                                                                       +
                                                                       2)
                                                                      (("1"
                                                                        (case
                                                                         "FF(p) = 1")
                                                                        (("1"
                                                                          (replace
                                                                           -1)
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (case
                                                                               "divides(p,sigma(1, p - 1, FF))")
                                                                              (("1"
                                                                                (expand
                                                                                 "divides"
                                                                                 -1)
                                                                                (("1"
                                                                                  (skolem
                                                                                   -1
                                                                                   "kp")
                                                                                  (("1"
                                                                                    (replace
                                                                                     -1)
                                                                                    (("1"
                                                                                      (skolem
                                                                                       -6
                                                                                       "rj")
                                                                                      (("1"
                                                                                        (replace
                                                                                         -6)
                                                                                        (("1"
                                                                                          (case
                                                                                           "C(p,0) = 1")
                                                                                          (("1"
                                                                                            (replace
                                                                                             -1)
                                                                                            (("1"
                                                                                              (assert)
                                                                                              (("1"
                                                                                                (inst
                                                                                                 +
                                                                                                 "kp+rj")
                                                                                                (("1"
                                                                                                  (assert)
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (hide-all-but
                                                                                             1)
                                                                                            (("2"
                                                                                              (expand
                                                                                               "C")
                                                                                              (("2"
                                                                                                (assert)
                                                                                                nil
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (hide
                                                                                 2)
                                                                                (("2"
                                                                                  (hide
                                                                                   (-1
                                                                                    -2))
                                                                                  (("2"
                                                                                    (expand
                                                                                     "divides")
                                                                                    (("2"
                                                                                      (inst
                                                                                       +
                                                                                       "sigma(1,p-1,GG)")
                                                                                      (("2"
                                                                                        (rewrite
                                                                                         "sigma_scal"
                                                                                         :dir
                                                                                         rl)
                                                                                        (("2"
                                                                                          (rewrite
                                                                                           "sigma_eq")
                                                                                          (("2"
                                                                                            (hide
                                                                                             2)
                                                                                            (("2"
                                                                                              (skosimp*)
                                                                                              (("2"
                                                                                                (inst
                                                                                                 -
                                                                                                 "n!1")
                                                                                                (("2"
                                                                                                  (assert)
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("3"
                                                                                (hide
                                                                                 2)
                                                                                (("3"
                                                                                  (case
                                                                                   "FORALL (TJ:nat): EXISTS (kr:nat): kr = sigma[nat](1,TJ,FF)")
                                                                                  (("1"
                                                                                    (inst?)
                                                                                    (("1"
                                                                                      (skeep
                                                                                       -1)
                                                                                      (("1"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil)
                                                                                   ("2"
                                                                                    (hide
                                                                                     2)
                                                                                    (("2"
                                                                                      (case
                                                                                       "FORALL (TJ:nat): EXISTS (kr:nat): kr = FF(TJ)")
                                                                                      (("1"
                                                                                        (hide-all-but
                                                                                         (-1
                                                                                          1))
                                                                                        (("1"
                                                                                          (induct
                                                                                           "TJ")
                                                                                          (("1"
                                                                                            (expand
                                                                                             "sigma"
                                                                                             +)
                                                                                            (("1"
                                                                                              (inst?)
                                                                                              nil
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (skeep)
                                                                                            (("2"
                                                                                              (assert)
                                                                                              (("2"
                                                                                                (skeep
                                                                                                 -1)
                                                                                                (("2"
                                                                                                  (expand
                                                                                                   "sigma"
                                                                                                   +)
                                                                                                  (("2"
                                                                                                    (replace
                                                                                                     -1
                                                                                                     :dir
                                                                                                     rl)
                                                                                                    (("2"
                                                                                                      (inst
                                                                                                       -
                                                                                                       "1+j!1")
                                                                                                      (("2"
                                                                                                        (skosimp*)
                                                                                                        (("2"
                                                                                                          (replace
                                                                                                           -2
                                                                                                           :dir
                                                                                                           rl)
                                                                                                          (("2"
                                                                                                            (inst
                                                                                                             +
                                                                                                             "kr!1+kr")
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (hide
                                                                                         2)
                                                                                        (("2"
                                                                                          (hide-all-but
                                                                                           1)
                                                                                          (("2"
                                                                                            (skeep)
                                                                                            (("2"
                                                                                              (expand
                                                                                               "FF")
                                                                                              (("2"
                                                                                                (assert)
                                                                                                (("2"
                                                                                                  (case
                                                                                                   "TJ>p")
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    (("1"
                                                                                                      (inst
                                                                                                       +
                                                                                                       "0")
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil)
                                                                                                   ("2"
                                                                                                    (assert)
                                                                                                    (("2"
                                                                                                      (typepred
                                                                                                       "A")
                                                                                                      (("2"
                                                                                                        (case
                                                                                                         "A = 0")
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          (("1"
                                                                                                            (replace
                                                                                                             -1)
                                                                                                            (("1"
                                                                                                              (case
                                                                                                               "TJ = p")
                                                                                                              (("1"
                                                                                                                (replace
                                                                                                                 -1)
                                                                                                                (("1"
                                                                                                                  (case
                                                                                                                   "C(p,p) = 1")
                                                                                                                  (("1"
                                                                                                                    (replace
                                                                                                                     -1)
                                                                                                                    (("1"
                                                                                                                      (assert)
                                                                                                                      (("1"
                                                                                                                        (lemma
                                                                                                                         "expt_1i")
                                                                                                                        (("1"
                                                                                                                          (inst?)
                                                                                                                          (("1"
                                                                                                                            (replace
                                                                                                                             -1)
                                                                                                                            (("1"
                                                                                                                              (assert)
                                                                                                                              (("1"
                                                                                                                                (expand
                                                                                                                                 "^")
                                                                                                                                (("1"
                                                                                                                                  (expand
                                                                                                                                   "expt")
                                                                                                                                  (("1"
                                                                                                                                    (inst
                                                                                                                                     +
                                                                                                                                     "1")
                                                                                                                                    nil
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil)
                                                                                                                   ("2"
                                                                                                                    (hide-all-but
                                                                                                                     1)
                                                                                                                    (("2"
                                                                                                                      (expand
                                                                                                                       "C")
                                                                                                                      (("2"
                                                                                                                        (assert)
                                                                                                                        nil
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil)
                                                                                                               ("2"
                                                                                                                (assert)
                                                                                                                (("2"
                                                                                                                  (inst
                                                                                                                   +
                                                                                                                   "0")
                                                                                                                  (("2"
                                                                                                                    (expand
                                                                                                                     "^"
                                                                                                                     +)
                                                                                                                    (("2"
                                                                                                                      (expand
                                                                                                                       "expt"
                                                                                                                       +)
                                                                                                                      (("2"
                                                                                                                        (lift-if)
                                                                                                                        (("2"
                                                                                                                          (ground)
                                                                                                                          nil
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (assert)
                                                                                                          (("2"
                                                                                                            (rewrite
                                                                                                             "expt_1i")
                                                                                                            (("2"
                                                                                                              (assert)
                                                                                                              (("2"
                                                                                                                (lemma
                                                                                                                 "int_times_int_is_int")
                                                                                                                (("2"
                                                                                                                  (inst?)
                                                                                                                  (("1"
                                                                                                                    (inst
                                                                                                                     +
                                                                                                                     "C(p, TJ) * A ^ (p - TJ)")
                                                                                                                    (("1"
                                                                                                                      (assert)
                                                                                                                      nil
                                                                                                                      nil))
                                                                                                                    nil)
                                                                                                                   ("2"
                                                                                                                    (assert)
                                                                                                                    (("2"
                                                                                                                      (lemma
                                                                                                                       "int_expt")
                                                                                                                      (("2"
                                                                                                                        (expand
                                                                                                                         "^"
                                                                                                                         +)
                                                                                                                        (("2"
                                                                                                                          (propax)
                                                                                                                          nil
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (hide-all-but
                                                                           1)
                                                                          (("2"
                                                                            (expand
                                                                             "FF")
                                                                            (("2"
                                                                              (assert)
                                                                              (("2"
                                                                                (rewrite
                                                                                 "expt_1i")
                                                                                (("2"
                                                                                  (rewrite
                                                                                   "expt_x0")
                                                                                  (("2"
                                                                                    (expand
                                                                                     "C")
                                                                                    (("2"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (hide (-1 2))
                                      (("2"
                                        (case
                                         "FORALL (ii:nat): 1 <= ii AND ii <= p - 1 IMPLIES EXISTS (kk:nat): p*kk = FF(ii)")
                                        (("1"
                                          (inst
                                           +
                                           "LAMBDA (ii:nat): choose({kk:nat | 1 <= ii AND ii <= p - 1 IMPLIES p*kk = FF(ii)})")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (skosimp*)
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (invoke
                                                   (name "PK" "%1")
                                                   (! 1 1 2))
                                                  (("1"
                                                    (replace -1)
                                                    (("1"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (hide 2)
                                                    (("2"
                                                      (expand
                                                       "nonempty?")
                                                      (("2"
                                                        (expand
                                                         "empty?")
                                                        (("2"
                                                          (inst
                                                           -2
                                                           "ii!1")
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (skosimp*)
                                                              (("2"
                                                                (inst
                                                                 -
                                                                 "kk!1")
                                                                (("2"
                                                                  (expand
                                                                   "member")
                                                                  (("2"
                                                                    (propax)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (skosimp*)
                                            (("2"
                                              (inst - "ii!1")
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (expand "nonempty?")
                                                  (("2"
                                                    (expand "empty?")
                                                    (("2"
                                                      (invoke
                                                       (case "%1")
                                                       (! -2 1))
                                                      (("1"
                                                        (flatten)
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (skosimp*)
                                                            (("1"
                                                              (inst
                                                               -
                                                               "kk!1")
                                                              (("1"
                                                                (expand
                                                                 "member")
                                                                (("1"
                                                                  (propax)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (assert)
                                                        (("2"
                                                          (inst - "0")
                                                          (("2"
                                                            (expand
                                                             "member")
                                                            (("2"
                                                              (replace
                                                               1)
                                                              (("2"
                                                                (propax)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (hide 2)
                                          (("2"
                                            (skeep)
                                            (("2"
                                              (expand "FF")
                                              (("2"
                                                (lemma "expt_1i")
                                                (("2"
                                                  (rewrite -1)
                                                  (("2"
                                                    (hide -1)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (lemma
                                                         "prime_divides_choose")
                                                        (("2"
                                                          (inst
                                                           -
                                                           "ii"
                                                           "p")
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (expand
                                                               "divides")
                                                              (("2"
                                                                (skosimp*)
                                                                (("2"
                                                                  (replace
                                                                   -1)
                                                                  (("2"
                                                                    (inst
                                                                     +
                                                                     "x!1*A^(p-ii)")
                                                                    (("1"
                                                                      (assert)
                                                                      nil
                                                                      nil)
                                                                     ("2"
                                                                      (assert)
                                                                      (("2"
                                                                        (case
                                                                         "x!1 > 0")
                                                                        (("1"
                                                                          (lemma
                                                                           "posreal_times_posreal_is_posreal")
                                                                          (("1"
                                                                            (inst
                                                                             -
--> --------------------

--> maximum size reached

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

¤ Dauer der Verarbeitung: 0.91 Sekunden  (vorverarbeitet)  ¤





Download des
Quellennavigators
Download des
sprechenden Kalenders

in der Quellcodebibliothek suchen




Haftungshinweis

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


Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.


Bot Zugriff