Anforderungen  |   Konzepte  |   Entwurf  |   Entwicklung  |   Qualitätssicherung  |   Lebenszyklus  |   Steuerung
 
 
 
 


Quelle  fermats_little_theorem.prf

  Sprache: Lisp
 

(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
                                                                             -
                                                                             "x!1"
                                                                             "A^(p-ii)")
                                                                            (("1"
                                                                              (assert)
                                                                              (("1"
                                                                                (lemma
                                                                                 "int_times_int_is_int")
                                                                                (("1"
                                                                                  (inst?)
                                                                                  (("1"
                                                                                    (assert)
                                                                                    (("1"
                                                                                      (case
                                                                                       "FORALL (krp:nat): integer_pred(A^krp)")
                                                                                      (("1"
                                                                                        (inst?)
                                                                                        nil
                                                                                        nil)
                                                                                       ("2"
                                                                                        (hide
                                                                                         2)
                                                                                        (("2"
                                                                                          (hide
                                                                                           2)
                                                                                          (("2"
                                                                                            (induct
                                                                                             "krp")
                                                                                            (("1"
                                                                                              (grind)
                                                                                              nil
                                                                                              nil)
                                                                                             ("2"
                                                                                              (grind)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (assert)
                                                                              nil
                                                                              nil)
                                                                             ("3"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (lemma
                                                                           "nnreal_times_nnreal_is_nnreal")
                                                                          (("2"
                                                                            (inst
                                                                             -
                                                                             "p"
                                                                             "-x!1")
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil)
                                                                             ("2"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide 2)
                                (("2" (grind) nil nil))
                                nil)
                               ("3"
                                (hide 2)
                                (("3" (grind) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((posint_exp application-judgement "posint" exponentiation nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (binomial_theorem formula-decl nil polynomials "reals/")
    (NOT const-decl "[bool -> bool]" booleans nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (C const-decl "posnat" binomial "reals/")
    (posnat nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (<= const-decl "bool" reals nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (> const-decl "bool" reals nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (nnrat_times_nnrat_is_nnrat application-judgement "nonneg_rat"
     rationals nil)
    (nnreal_times_nnreal_is_nnreal judgement-tcc nil real_types nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (minus_int_is_int application-judgement "int" integers nil)
    (posreal_times_posreal_is_posreal judgement-tcc nil real_types nil)
    (factorial def-decl "posnat" factorial "ints/")
    (even_minus_even_is_even application-judgement "even_int" integers
     nil)
    (nzrat_div_nzrat_is_nzrat application-judgement "nzrat" rationals
     nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (ii skolem-const-decl "nat" fermats_little_theorem nil)
    (x!1 skolem-const-decl "int" fermats_little_theorem nil)
    (rat_times_rat_is_rat application-judgement "rat" rationals nil)
    (prime_divides_choose formula-decl nil fermats_little_theorem nil)
    (set type-eq-decl nil sets nil)
    (nonempty? const-decl "bool" sets nil)
    (choose const-decl "(p)" sets nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (sigma def-decl "real" sigma "reals/")
    (FF skolem-const-decl "[nat -> rational]" fermats_little_theorem
     nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (expt_x0 formula-decl nil exponentiation nil)
    (divides const-decl "bool" divides nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (posrat_div_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (factorial_0 formula-decl nil factorial "ints/")
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (sigma_nat application-judgement "nat" sigma_nat "reals/")
    (sigma_nnreal application-judgement "nnreal" sigma_nat "reals/")
    (sigma_eq formula-decl nil sigma "reals/")
    (subrange type-eq-decl nil integers nil)
    (sigma_scal formula-decl nil sigma "reals/")
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (A skolem-const-decl "nat" fermats_little_theorem nil)
    (p skolem-const-decl "nat" fermats_little_theorem nil)
    (TJ skolem-const-decl "nat" fermats_little_theorem nil)
    (int_expt judgement-tcc nil exponentiation nil)
    (int_times_int_is_int judgement-tcc nil integers nil)
    (expt_1i formula-decl nil exponentiation nil)
    (posnat_expt application-judgement "posnat" exponentiation nil)
    (nnrat_exp application-judgement "nnrat" exponentiation nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (T_high type-eq-decl nil sigma "reals/")
    (T_low type-eq-decl nil sigma "reals/")
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (sigma_split formula-decl nil sigma "reals/")
    (= const-decl "[T, T -> boolean]" equalities nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nat_expt application-judgement "nat" 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)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (expt def-decl "real" exponentiation nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (^ const-decl "real" exponentiation nil)
    (/= const-decl "boolean" notequal nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (eq_mod const-decl "bool" eq_mod nil)
    (< const-decl "bool" reals nil)
    (prime? const-decl "bool" primes "ints/")
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (pred type-eq-decl nil defined_types 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)
    (nat_exp application-judgement "nat" exponentiation nil))
   shostak))
 (fermats_little_theorem_TCC1 0
  (fermats_little_theorem_TCC1-1 nil 3564160286
   ("" (subtype-tcc) nil nil)
   ((/= const-decl "boolean" notequal nil)
    (divides const-decl "bool" divides nil)
    (prime? const-decl "bool" primes "ints/"))
   nil))
 (fermats_little_theorem 0
  (fermats_little_theorem-1 nil 3564160294
   ("" (lemma "Fermats_Little")
    (("" (skeep)
      (("" (inst - "mod(k,p)" "p")
        (("1" (assert)
          (("1" (typepred "mod(k,p)")
            (("1" (case "NOT mod(k,p)>=0")
              (("1" (hide-all-but 1)
                (("1" (expand "mod")
                  (("1" (both-sides "+" "p*floor(k/p)" 1)
                    (("1" (assert)
                      (("1" (typepred "floor(k/p)")
                        (("1" (mult-by -1 "p") (("1" (assertnil nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (expand "abs" -2)
                (("2" (assert)
                  (("2" (expand "eq_mod")
                    (("2" (expand "mod")
                      (("2" (name "K" "floor(k/p)")
                        (("2" (replace -1)
                          (("2" (skolem -4 "D")
                            (("2" (assert)
                              (("2"
                                (lemma "binomial_theorem")
                                (("2"
                                  (inst - "p" "k" "-p*K")
                                  (("2"
                                    (replace -1)
                                    (("2"
                                      (hide -1)
                                      (("2"
                                        (assert)
                                        (("2"
                                          (invoke
                                           (name "FF" "%1")
                                           (! -4 1 3))
                                          (("1"
                                            (replace -1)
                                            (("1"
                                              (expand "sigma")
                                              (("1"
                                                (expand "FF" -5 1)
                                                (("1"
                                                  (case
                                                   "(-p * K)^0 = 1")
                                                  (("1"
                                                    (replace -1)
                                                    (("1"
                                                      (case
                                                       "C(p,p) = 1")
                                                      (("1"
                                                        (replaces -1)
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (case
                                                             "EXISTS (G:int): p*G = sigma(0,p-1,FF)")
                                                            (("1"
                                                              (skosimp*)
                                                              (("1"
                                                                (replace
                                                                 -1
                                                                 :dir
                                                                 rl)
                                                                (("1"
                                                                  (inst
                                                                   +
                                                                   "D-K-G!1")
                                                                  (("1"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (hide 2)
                                                              (("2"
                                                                (name
                                                                 "KR"
                                                                 " (LAMBDA (i: nat):
                                                   IF i >= p THEN 0 ELSE -C(p, i) * (-p)^(p-i-1) * K ^ (p - i) * k ^ i ENDIF)")
                                                                (("1"
                                                                  (inst
                                                                   +
                                                                   "sigma(0,p-1,KR)")
                                                                  (("1"
                                                                    (rewrite
                                                                     "sigma_scal"
                                                                     :dir
                                                                     rl)
                                                                    (("1"
                                                                      (rewrite
                                                                       "sigma_eq")
                                                                      (("1"
                                                                        (hide
                                                                         2)
                                                                        (("1"
                                                                          (skeep)
                                                                          (("1"
                                                                            (typepred
                                                                             "n")
                                                                            (("1"
                                                                              (expand
                                                                               "KR"
                                                                               +)
                                                                              (("1"
                                                                                (expand
                                                                                 "FF"
                                                                                 +)
                                                                                (("1"
                                                                                  (lemma
                                                                                   "expt_plus")
                                                                                  (("1"
                                                                                    (inst
                                                                                     -
                                                                                     "-1-n+p"
                                                                                     "1"
                                                                                     "-p")
                                                                                    (("1"
                                                                                      (assert)
                                                                                      (("1"
                                                                                        (case
                                                                                         "(-p)^1 = -p")
                                                                                        (("1"
                                                                                          (assert)
                                                                                          (("1"
                                                                                            (replaces
                                                                                             -1)
                                                                                            (("1"
                                                                                              (lemma
                                                                                               "mult_expt")
                                                                                              (("1"
                                                                                                (inst
                                                                                                 -
                                                                                                 "p-n"
                                                                                                 "K"
                                                                                                 "-p")
                                                                                                (("1"
                                                                                                  (assert)
                                                                                                  nil
                                                                                                  nil)
                                                                                                 ("2"
                                                                                                  (assert)
                                                                                                  (("2"
                                                                                                    (flatten)
                                                                                                    (("2"
                                                                                                      (replace
                                                                                                       -1)
                                                                                                      (("2"
                                                                                                        (assert)
                                                                                                        (("2"
                                                                                                          (expand
                                                                                                           "^"
                                                                                                           +)
                                                                                                          (("2"
                                                                                                            (expand
                                                                                                             "expt"
                                                                                                             +)
                                                                                                            (("2"
                                                                                                              (assert)
                                                                                                              (("2"
                                                                                                                (lift-if)
                                                                                                                (("2"
                                                                                                                  (ground)
                                                                                                                  nil
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (hide-all-but
                                                                                           1)
                                                                                          (("2"
                                                                                            (grind)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (case
                                                                     "FORALL (jj:nat): jj<=p-1 IMPLIES rational_pred(sigma[nat](0, jj, KR)) AND
                                integer_pred(sigma[nat](0, jj, KR))")
                                                                    (("1"
                                                                      (inst?)
                                                                      (("1"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (hide
                                                                       2)
                                                                      (("2"
                                                                        (induct
                                                                         "jj")
                                                                        (("1"
                                                                          (hide
                                                                           -)
                                                                          (("1"
                                                                            (flatten)
                                                                            (("1"
                                                                              (expand
                                                                               "sigma")
                                                                              (("1"
                                                                                (expand
                                                                                 "sigma")
                                                                                (("1"
                                                                                  (assert)
                                                                                  (("1"
                                                                                    (expand
                                                                                     "KR")
                                                                                    (("1"
                                                                                      (assert)
                                                                                      (("1"
                                                                                        (rewrite
                                                                                         "int_times_int_is_int")
                                                                                        (("1"
                                                                                          (rewrite
                                                                                           "int_times_int_is_int")
                                                                                          (("1"
                                                                                            (rewrite
                                                                                             "int_times_int_is_int")
                                                                                            (("1"
                                                                                              (lemma
                                                                                               "int_expt")
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "^")
                                                                                                (("1"
                                                                                                  (propax)
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (hide
                                                                           -)
                                                                          (("2"
                                                                            (skeep)
                                                                            (("2"
                                                                              (assert)
                                                                              (("2"
                                                                                (flatten)
                                                                                (("2"
                                                                                  (expand
                                                                                   "sigma"
                                                                                   +)
                                                                                  (("2"
                                                                                    (assert)
                                                                                    (("2"
                                                                                      (split)
                                                                                      (("1"
                                                                                        (rewrite
                                                                                         "rat_plus_rat_is_rat")
                                                                                        nil
                                                                                        nil)
                                                                                       ("2"
                                                                                        (rewrite
                                                                                         "int_plus_int_is_int")
                                                                                        (("2"
                                                                                          (expand
                                                                                           "KR"
                                                                                           1)
                                                                                          (("2"
                                                                                            (expand
                                                                                             "^")
                                                                                            (("2"
                                                                                              (propax)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (assert)
                                                                  (("2"
                                                                    (skosimp*)
                                                                    (("2"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("3"
                                                                  (skosimp*)
                                                                  (("3"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (expand "C")
                                                        (("2"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (hide-all-but 1)
                                                    (("2"
                                                      (grind)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (skosimp*)
                                            (("2" (assertnil nil))
                                            nil)
                                           ("3"
                                            (skosimp*)
                                            (("3" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (assert)
              (("2" (flatten)
                (("2" (expand "prime?") (("2" (propax) nil nil)) nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (assert)
          (("2" (hide 2)
            (("2" (expand "mod")
              (("2" (both-sides "+" "p*floor(k/p)" 1)
                (("2" (assert)
                  (("2" (typepred "floor(k/p)")
                    (("2" (mult-by -1 "p") (("2" (assertnil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("3" (expand "prime?")
          (("3" (flatten) (("3" (assertnil nil)) nil)) nil))
        nil))
      nil))
    nil)
   ((real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_exp application-judgement "int" exponentiation nil)
    (prime? const-decl "bool" primes "ints/")
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (both_sides_times_pos_le1_imp formula-decl nil extra_real_props
     nil)
    (div_cancel2 formula-decl nil real_props nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (real_le_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)
    (both_sides_plus_ge1 formula-decl nil real_props nil)
    (divides const-decl "bool" divides nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (floor const-decl "{i | i <= x & x < i + 1}" floor_ceil nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (<= const-decl "bool" reals nil)
    (integer nonempty-type-from-decl nil integers nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (rat_div_nzrat_is_rat application-judgement "rat" rationals nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (minus_int_is_int application-judgement "int" integers nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (rat nonempty-type-eq-decl nil rationals nil)
    (^ const-decl "real" exponentiation nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (C const-decl "posnat" binomial "reals/")
    (posnat nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (sigma def-decl "real" sigma "reals/")
    (real_plus_real_is_real application-judgement "real" reals nil)
    (KR skolem-const-decl "[nat -> rat]" fermats_little_theorem nil)
    (sigma_eq formula-decl nil sigma "reals/")
    (expt_plus formula-decl nil exponentiation nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (nzrat_div_nzrat_is_nzrat application-judgement "nzrat" rationals
     nil)
    (mult_expt formula-decl nil exponentiation nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (int_expt application-judgement "int" exponentiation nil)
    (expt def-decl "real" exponentiation nil)
    (nat_exp application-judgement "nat" exponentiation nil)
    (int_times_even_is_even application-judgement "even_int" integers
     nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (K skolem-const-decl "{i | i <= k / p & k / p < 1 + i}"
     fermats_little_theorem nil)
    (nzreal nonempty-type-eq-decl nil reals nil)
    (subrange type-eq-decl nil integers nil)
    (minus_nzint_is_nzint application-judgement "nzint" integers nil)
    (sigma_scal formula-decl nil sigma "reals/")
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (rat_plus_rat_is_rat judgement-tcc nil rationals nil)
    (int_plus_int_is_int judgement-tcc nil integers nil)
    (int_expt judgement-tcc nil exponentiation nil)
    (int_times_int_is_int judgement-tcc nil integers nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (T_high type-eq-decl nil sigma "reals/")
    (T_low type-eq-decl nil sigma "reals/")
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (factorial_0 formula-decl nil factorial "ints/")
    (posrat_div_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (rat_exp application-judgement "rat" exponentiation nil)
    (FF skolem-const-decl "[nat -> rat]" fermats_little_theorem nil)
    (rat_times_rat_is_rat application-judgement "rat" rationals nil)
    (binomial_theorem formula-decl nil polynomials "reals/")
    (eq_mod const-decl "bool" eq_mod nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (nonzero_integer nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (mod const-decl "{k | abs(k) < abs(j)}" mod nil)
    (k skolem-const-decl "int" fermats_little_theorem nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (/= const-decl "boolean" notequal nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (p skolem-const-decl "nat" fermats_little_theorem nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (Fermats_Little formula-decl nil fermats_little_theorem nil))
   shostak)))


Messung V0.5 in Prozent
C=100 H=100 G=100

¤ 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.0.86Bemerkung:  (vorverarbeitet am  2026-05-01) ¤

*Bot Zugriff






Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

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 und die Messung sind noch experimentell.






                                                                                                                                                                                                                                                                                                                                                                                                     


Neuigkeiten

     Aktuelles
     Motto des Tages

Software

     Produkte
     Quellcodebibliothek

Aktivitäten

     Artikel über Sicherheit
     Anleitung zur Aktivierung von SSL

Muße

     Gedichte
     Musik
     Bilder

Jenseits des Üblichen ....

Besucherstatistik

Besucherstatistik

Monitoring

Montastic status badge