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


Impressum primes_sum_squares.prf

  Sprache: Lisp
 

(primes_sum_squares
 (sum_of_two_squares?_TCC1 0
  (sum_of_two_squares?_TCC1-1 nil 3501936852 ("" (subtype-tcc) nil nil)
   ((/= const-decl "boolean" notequal nil)) nil))
 (sots_int?_TCC1 0
  (sots_int?_TCC1-1 nil 3501939999 ("" (subtype-tcc) nil nil)
   ((/= const-decl "boolean" notequal nil)) nil))
 (sots_int_def 0
  (sots_int_def-1 nil 3501939999
   ("" (skeep)
    (("" (expand "sum_of_two_squares?")
      (("" (expand "sots_int?")
        (("" (skosimp*)
          (("" (inst + "abs(ai!1)" "abs(bi!1)")
            (("" (replace -1)
              (("" (hide -) (("" (grind) nil nil)) nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nat_exp application-judgement "nat" exponentiation nil)
    (sum_of_two_squares? const-decl "bool" primes_sum_squares nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (minus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (nzrat_div_nzrat_is_nzrat application-judgement "nzrat" rationals
     nil)
    (int_expt application-judgement "int" exponentiation nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (expt def-decl "real" exponentiation nil)
    (^ const-decl "real" exponentiation nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (nonneg_real nonempty-type-eq-decl nil real_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)
    (int_abs_is_nonneg application-judgement "{j: nonneg_int | j >= i}"
     real_defs nil)
    (sots_int? const-decl "bool" primes_sum_squares nil)
    (int_exp application-judgement "int" exponentiation nil))
   shostak))
 (Brahmagupta_Fibonacci 0
  (Brahmagupta_Fibonacci-1 nil 3501936852
   ("" (skeep)
    (("" (typepred "ns")
      (("" (typepred "ms")
        (("" (expand "sum_of_two_squares?")
          (("" (skosimp*)
            (("" (name "vv" "(a!1*b!2-b!1*a!2)")
              (("" (case "vv>=0")
                (("1" (inst + "(a!1*a!2 + b!1*b!2)" "vv")
                  (("1" (replace -3)
                    (("1" (replace -4)
                      (("1" (hide -)
                        (("1" (expand "vv") (("1" (grind) nil nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (inst + "(a!1*a!2 + b!1*b!2)" "-vv")
                  (("1" (replace -2)
                    (("1" (replace -3)
                      (("1" (expand "vv" +)
                        (("1" (hide-all-but 2) (("1" (grind) nil nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (assertnil nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((sum_of_two_squares? const-decl "bool" primes_sum_squares nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals 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)
    (number nonempty-type-decl nil numbers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (nat_exp application-judgement "nat" exponentiation nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (minus_int_is_int application-judgement "int" integers nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (vv skolem-const-decl "int" primes_sum_squares nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nat_expt application-judgement "nat" exponentiation nil)
    (nzrat_div_nzrat_is_nzrat application-judgement "nzrat" rationals
     nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (int_expt application-judgement "int" exponentiation nil)
    (^ const-decl "real" exponentiation nil)
    (expt def-decl "real" exponentiation nil)
    (int_exp application-judgement "int" exponentiation nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil))
   shostak))
 (prime_divides 0
  (prime_divides-1 nil 3501939374
   ("" (case "FORALL (k,r:int): divides(k,r) IFF divides(k,-r)")
    (("1" (label "intlem" -1)
      (("1" (hide "intlem")
        (("1"
          (case "FORALL (nn, mm: posnat, p: (prime?)):
                                          divides(p, nn * mm) IMPLIES (divides(p, nn) OR divides(p, mm))")
          (("1" (skeep)
            (("1" (case "ai = 0 OR bi=0")
              (("1" (split -)
                (("1" (replace -1) (("1" (assertnil nil)) nil)
                 ("2" (replace -1) (("2" (assertnil nil)) nil))
                nil)
               ("2" (flatten)
                (("2"
                  (case "FORALL (nn, mm: posnat, p: (prime?)):
                                                          divides(p, (-nn) * mm) IMPLIES (divides(p, (-nn)) OR divides(p, mm))")
                  (("1"
                    (case "FORALL (nn, mm: posnat, p: (prime?)):
                                                                  divides(p, (-nn) * (-mm)) IMPLIES (divides(p, (-nn)) OR divides(p, (-mm)))")
                    (("1" (case "ai<0")
                      (("1" (case "bi<0")
                        (("1" (assert)
                          (("1" (inst -3 "-ai" "-bi" "p")
                            (("1" (assertnil nil)) nil))
                          nil)
                         ("2" (inst -3 "-ai" "bi" "p")
                          (("1" (assertnil nil)
                           ("2" (assertnil nil)
                           ("3" (assertnil nil))
                          nil))
                        nil)
                       ("2" (case "bi<0")
                        (("1" (inst -3 "-bi" "ai" "p")
                          (("1" (assertnil nil)
                           ("2" (assertnil nil)
                           ("3" (assertnil nil))
                          nil)
                         ("2" (inst -3 "ai" "bi" "p")
                          (("1" (assertnil nil)
                           ("2" (assertnil nil)
                           ("3" (assertnil nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide (2 3 4 5 6))
                      (("2" (skosimp*)
                        (("2" (inst - "nn!1" "mm!1" "p!1")
                          (("2" (assert)
                            (("2" (split -)
                              (("1"
                                (reveal "intlem")
                                (("1"
                                  (inst?)
                                  (("1" (assertnil nil))
                                  nil))
                                nil)
                               ("2"
                                (reveal "intlem")
                                (("2"
                                  (inst?)
                                  (("2" (assertnil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (hide (2 3 4 5 6))
                    (("2" (skosimp*)
                      (("2" (inst - "nn!1" "mm!1" "p!1")
                        (("2" (assert)
                          (("2" (split -)
                            (("1" (reveal "intlem")
                              (("1"
                                (inst?)
                                (("1" (assertnil nil))
                                nil))
                              nil)
                             ("2" (reveal "intlem")
                              (("2"
                                (inst?)
                                (("2" (assertnil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (hide 2)
            (("2" (skeep)
              (("2" (expand "divides" -)
                (("2" (skolem -1 "r")
                  (("2"
                    (case "FORALL (kr:posnat): (NOT divides(p,kr)) IMPLIES gcd(p,kr) = 1")
                    (("1" (inst - "mm")
                      (("1" (assert)
                        (("1" (lemma "gcd_factors")
                          (("1" (inst?)
                            (("1" (assert)
                              (("1"
                                (skosimp*)
                                (("1"
                                  (replace -2)
                                  (("1"
                                    (mult-by -1 "nn")
                                    (("1"
                                      (assert)
                                      (("1"
                                        (expand "divides" 1)
                                        (("1"
                                          (name
                                           "vv"
                                           "ip!1*nn + jp!1*r")
                                          (("1"
                                            (case "nn=p*vv")
                                            (("1"
                                              (case "vv > 0")
                                              (("1"
                                                (inst + "vv")
                                                nil
                                                nil)
                                               ("2"
                                                (lemma
                                                 "posreal_times_posreal_is_posreal")
                                                (("2"
                                                  (inst - "p" "-vv")
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil)
                                                   ("2"
                                                    (assert)
                                                    nil
                                                    nil)
                                                   ("3"
                                                    (typepred "p")
                                                    (("3"
                                                      (expand "prime?")
                                                      (("3"
                                                        (ground)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide-all-but 1)
                      (("2" (skeep)
                        (("2" (typepred "gcd(p,kr)")
                          (("2" (typepred "p")
                            (("2" (expand "prime?")
                              (("2"
                                (flatten)
                                (("2"
                                  (inst - "gcd(p,kr)")
                                  (("2" (assertnil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil)
     ("2" (hide 2)
      (("2"
        (case "FORALL (k, r: int): divides(k, r) IMPLIES divides(k, -r)")
        (("1" (skeep)
          (("1" (ground)
            (("1" (inst - "k" "r") (("1" (assertnil nil)) nil)
             ("2" (inst - "k" "-r") (("2" (assertnil nil)) nil))
            nil))
          nil)
         ("2" (hide 2)
          (("2" (skeep)
            (("2" (expand "divides")
              (("2" (skosimp*)
                (("2" (inst + "-x!1") (("2" (assertnil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((OR const-decl "[bool, bool -> bool]" booleans nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (prime? const-decl "bool" primes "ints/")
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (int_times_even_is_even application-judgement "even_int" integers
     nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (nzint_times_nzint_is_nzint application-judgement "nzint" integers
     nil)
    (minus_nzint_is_nzint application-judgement "nzint" integers nil)
    (< const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (ai skolem-const-decl "int" primes_sum_squares nil)
    (bi skolem-const-decl "int" primes_sum_squares 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)
    (gcd_factors formula-decl nil gcd "ints/")
    (p skolem-const-decl "(prime?)" primes_sum_squares nil)
    (vv skolem-const-decl "int" primes_sum_squares nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (posreal_times_posreal_is_posreal judgement-tcc nil real_types nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (both_sides_times1_imp formula-decl nil extra_real_props nil)
    (gcd const-decl "{k: posnat | divides(k, i) AND divides(k, j)}" gcd
         "ints/")
    (/= const-decl "boolean" notequal nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (minus_int_is_int application-judgement "int" integers nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans 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)
    (IFF const-decl "[bool, bool -> bool]" booleans nil)
    (divides const-decl "bool" divides nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield -> numfield]" number_fields nil))
   nil))
 (sots_div_prime_closed_TCC1 0
  (sots_div_prime_closed_TCC1-1 nil 3501939374
   ("" (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)
    (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)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (sum_of_two_squares? const-decl "bool" primes_sum_squares nil)
    (prime_sum_of_two_squares? const-decl "bool" primes_sum_squares
     nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (nat_expt application-judgement "nat" exponentiation nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (prime? const-decl "bool" primes "ints/")
    (^ const-decl "real" exponentiation nil)
    (divides const-decl "bool" divides nil)
    (/= const-decl "boolean" notequal nil))
   nil))
 (sots_div_prime_closed_TCC2 0
  (sots_div_prime_closed_TCC2-1 nil 3501939374
   ("" (skeep)
    (("" (expand "divides")
      (("" (skosimp*)
        (("" (case "ns/ps = x!1")
          (("1" (assert)
            (("1" (cross-mult 1) (("1" (assertnil nil)) nil)) nil)
           ("2" (cross-mult 1) (("2" (assertnil nil)) nil)
           ("3" (assertnil nil))
          nil))
        nil))
      nil))
    nil)
   ((divides const-decl "bool" divides nil)
    (prime_sum_of_two_squares? const-decl "bool" primes_sum_squares
     nil)
    (sum_of_two_squares? const-decl "bool" primes_sum_squares 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)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/= const-decl "boolean" notequal nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (rat_div_nzrat_is_rat application-judgement "rat" rationals nil)
    (div_mult_pos_ge1 formula-decl nil real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (div_cancel3 formula-decl nil real_props nil))
   nil))
 (sots_div_prime_closed 0
  (sots_div_prime_closed-1 nil 3501939558
   (""
    (case "FORALL (rr:nzint,rs:int): divides(rr,rs) IMPLIES integer_pred(rs/rr)")
    (("1" (label "integerpredlem" -1)
      (("1" (hide "integerpredlem")
        (("1"
          (case "FORALL (rr,rs:int): divides(rr,rs) IFF divides(rr,-rs)")
          (("1" (label "intlem" -1)
            (("1" (hide "intlem")
              (("1" (skeep)
                (("1" (typepred "ns")
                  (("1" (typepred "ps")
                    (("1"
                      (case "EXISTS (a,b,pp,qq:nat): ns = a^2+b^2 AND ps = pp^2+qq^2")
                      (("1" (skeep -1)
                        (("1" (hide -3)
                          (("1" (hide -3)
                            (("1"
                              (case "divides(ps,(pp*b-a*qq)*(pp*b+a*qq))")
                              (("1"
                                (lemma "prime_divides")
                                (("1"
                                  (inst?)
                                  (("1"
                                    (assert)
                                    (("1"
                                      (hide -2)
                                      (("1"
                                        (split -)
                                        (("1"
                                          (case
                                           "divides(ps,(a*pp+b*qq)^2)")
                                          (("1"
                                            (case
                                             "divides(ps^2,(a*pp+b*qq)^2)")
                                            (("1"
                                              (name
                                               "f1"
                                               "(a*pp+b*qq)/ps")
                                              (("1"
                                                (name
                                                 "f2"
                                                 "(a*qq-b*pp)/ps")
                                                (("1"
                                                  (lemma
                                                   "sots_int_def")
                                                  (("1"
                                                    (inst?)
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (hide 2)
                                                        (("1"
                                                          (case
                                                           "integer_pred(f1) and integer_pred(f2)")
                                                          (("1"
                                                            (flatten)
                                                            (("1"
                                                              (expand
                                                               "sots_int?")
                                                              (("1"
                                                                (inst
                                                                 +
                                                                 "f1"
                                                                 "f2")
                                                                (("1"
                                                                  (replace
                                                                   -8
                                                                   +)
                                                                  (("1"
                                                                    (replace
                                                                     -9
                                                                     +)
                                                                    (("1"
                                                                      (expand
                                                                       "f1"
                                                                       +)
                                                                      (("1"
                                                                        (expand
                                                                         "f2"
                                                                         +)
                                                                        (("1"
                                                                          (replace
                                                                           -9
                                                                           +
                                                                           :dir
                                                                           rl)
                                                                          (("1"
                                                                            (case
                                                                             "ps*(a^2+b^2) = (a * qq - b * pp)^2+(a * pp + b * qq)^2")
                                                                            (("1"
                                                                              (hide-all-but
                                                                               (-1
                                                                                1))
                                                                              (("1"
                                                                                (name
                                                                                 "pz"
                                                                                 "a^2+b^2")
                                                                                (("1"
                                                                                  (replace
                                                                                   -1)
                                                                                  (("1"
                                                                                    (hide
                                                                                     -1)
                                                                                    (("1"
                                                                                      (name
                                                                                       "zz"
                                                                                       "(a * qq - b * pp)")
                                                                                      (("1"
                                                                                        (replace
                                                                                         -1)
                                                                                        (("1"
                                                                                          (name
                                                                                           "sz"
                                                                                           "(a * pp + b * qq)")
                                                                                          (("1"
                                                                                            (replace
                                                                                             -1)
                                                                                            (("1"
                                                                                              (hide
                                                                                               -1)
                                                                                              (("1"
                                                                                                (hide
                                                                                                 -1)
                                                                                                (("1"
                                                                                                  (grind)
                                                                                                  (("1"
                                                                                                    (mult-by
                                                                                                     1
                                                                                                     "ps^2")
                                                                                                    (("1"
                                                                                                      (grind)
                                                                                                      (("1"
                                                                                                        (field)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (typepred
                                                                                                       "ps")
                                                                                                      (("2"
                                                                                                        (expand
                                                                                                         "prime_sum_of_two_squares?")
                                                                                                        (("2"
                                                                                                          (expand
                                                                                                           "prime?")
                                                                                                          (("2"
                                                                                                            (ground)
                                                                                                            (("2"
                                                                                                              (lemma
                                                                                                               "posreal_times_posreal_is_posreal")
                                                                                                              (("2"
                                                                                                                (inst?)
                                                                                                                (("2"
                                                                                                                  (assert)
                                                                                                                  nil
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (hide
                                                                               2)
                                                                              (("2"
                                                                                (replace
                                                                                 -9
                                                                                 +)
                                                                                (("2"
                                                                                  (hide
                                                                                   -)
                                                                                  (("2"
                                                                                    (grind)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (reveal
                                                             "integerpredlem")
                                                            (("2"
                                                              (split +)
                                                              (("1"
                                                                (expand
                                                                 "f1"
                                                                 +)
                                                                (("1"
                                                                  (inst?)
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (lemma
                                                                       "prime_divides")
                                                                      (("1"
                                                                        (inst
                                                                         -
                                                                         "a*pp+b*qq"
                                                                         "a*pp+b*qq"
                                                                         "ps")
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (expand
                                                                             "^")
                                                                            (("1"
                                                                              (expand
                                                                               "expt")
                                                                              (("1"
                                                                                (expand
                                                                                 "expt")
                                                                                (("1"
                                                                                  (expand
                                                                                   "expt")
                                                                                  (("1"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (typepred
                                                                           "ps")
                                                                          (("2"
                                                                            (expand
                                                                             "prime_sum_of_two_squares?")
                                                                            (("2"
                                                                              (ground)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (expand
                                                                 "f2"
                                                                 +)
                                                                (("2"
                                                                  (inst?)
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (reveal
                                                                       "intlem")
                                                                      (("2"
                                                                        (inst?)
                                                                        (("2"
                                                                          (assert)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (reveal
                                                       "integerpredlem")
                                                      (("2"
                                                        (inst?)
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (typepred
                                                             "ps")
                                                            (("2"
                                                              (expand
                                                               "prime_sum_of_two_squares?")
                                                              (("2"
                                                                (expand
                                                                 "prime?")
                                                                (("2"
                                                                  (flatten)
                                                                  (("2"
                                                                    (cross-mult
                                                                     1)
                                                                    (("2"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (lemma "prime_divides")
                                              (("2"
                                                (inst
                                                 -
                                                 "a*pp+b*qq"
                                                 "a*pp+b*qq"
                                                 "ps")
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (case
                                                     "divides(ps, a * pp + b * qq)")
                                                    (("1"
                                                      (hide -2)
                                                      (("1"
                                                        (expand
                                                         "divides"
                                                         (-1 1))
                                                        (("1"
                                                          (skosimp*)
                                                          (("1"
                                                            (inst
                                                             +
                                                             "x!1^2")
                                                            (("1"
                                                              (replace
                                                               -1)
                                                              (("1"
                                                                (hide-all-but
                                                                 1)
                                                                (("1"
                                                                  (grind)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (assert)
                                                      (("2"
                                                        (expand "^")
                                                        (("2"
                                                          (expand
                                                           "expt"
                                                           -1)
                                                          (("2"
                                                            (expand
                                                             "expt"
                                                             -1)
                                                            (("2"
                                                              (expand
                                                               "expt"
                                                               -1)
                                                              (("2"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (typepred "ps")
                                                  (("2"
                                                    (expand
                                                     "prime_sum_of_two_squares?")
                                                    (("2"
                                                      (ground)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (lemma "divides_sum")
                                            (("2"
                                              (inst
                                               -
                                               "ns*ps"
                                               "-(a*qq-b*pp)^2"
                                               "ps")
                                              (("2"
                                                (split -)
                                                (("1"
                                                  (replace -3 -1)
                                                  (("1"
                                                    (replace -4 -1)
                                                    (("1"
                                                      (grind
                                                       :exclude
                                                       ("divides"
                                                        "sum_of_two_squares?"))
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (hide-all-but (-1 1))
                                                  (("2"
                                                    (expand "divides")
                                                    (("2"
                                                      (skosimp*)
                                                      (("2"
                                                        (inst
                                                         +
                                                         "x!1*(-pp*b+a*qq)")
                                                        (("2"
                                                          (grind)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("3"
                                                  (hide-all-but 1)
                                                  (("3"
                                                    (expand "divides")
                                                    (("3"
                                                      (inst?)
                                                      (("3"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (case
                                           "divides(ps,(a*pp-b*qq)^2)")
                                          (("1"
                                            (case
                                             "divides(ps^2,(a*pp-b*qq)^2)")
                                            (("1"
                                              (name
                                               "f1"
                                               "(a*pp-b*qq)/ps")
                                              (("1"
                                                (name
                                                 "f2"
                                                 "(a*qq+b*pp)/ps")
                                                (("1"
                                                  (lemma
                                                   "sots_int_def")
                                                  (("1"
                                                    (inst?)
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (hide 2)
                                                        (("1"
                                                          (case
                                                           "integer_pred(f1) and integer_pred(f2)")
                                                          (("1"
                                                            (flatten)
                                                            (("1"
                                                              (expand
                                                               "sots_int?")
                                                              (("1"
                                                                (inst
                                                                 +
                                                                 "f1"
                                                                 "f2")
                                                                (("1"
                                                                  (replace
                                                                   -8
                                                                   +)
                                                                  (("1"
                                                                    (replace
                                                                     -9
                                                                     +)
                                                                    (("1"
                                                                      (expand
                                                                       "f1"
                                                                       +)
                                                                      (("1"
                                                                        (expand
                                                                         "f2"
                                                                         +)
                                                                        (("1"
                                                                          (replace
                                                                           -9
                                                                           +
                                                                           :dir
                                                                           rl)
                                                                          (("1"
                                                                            (case
                                                                             "ps*(a ^ 2 + b ^ 2) =
                                                             (a * pp - b * qq) ^ 2 + (a * qq + b * pp) ^ 2")
                                                                            (("1"
                                                                              (hide-all-but
                                                                               (-1
                                                                                1))
                                                                              (("1"
                                                                                (name
                                                                                 "pz"
                                                                                 "a^2+b^2")
                                                                                (("1"
                                                                                  (replace
                                                                                   -1)
                                                                                  (("1"
                                                                                    (hide
                                                                                     -1)
                                                                                    (("1"
                                                                                      (name
                                                                                       "zz"
                                                                                       "(a * pp - b * qq)")
                                                                                      (("1"
                                                                                        (replace
                                                                                         -1)
                                                                                        (("1"
                                                                                          (name
                                                                                           "sz"
                                                                                           "(a * qq + b * pp)")
                                                                                          (("1"
                                                                                            (replace
                                                                                             -1)
                                                                                            (("1"
                                                                                              (hide
                                                                                               -1)
                                                                                              (("1"
                                                                                                (hide
                                                                                                 -1)
                                                                                                (("1"
                                                                                                  (grind)
                                                                                                  (("1"
                                                                                                    (mult-by
                                                                                                     1
                                                                                                     "ps^2")
                                                                                                    (("1"
                                                                                                      (grind)
                                                                                                      (("1"
                                                                                                        (field)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (typepred
                                                                                                       "ps")
                                                                                                      (("2"
                                                                                                        (expand
                                                                                                         "prime_sum_of_two_squares?")
                                                                                                        (("2"
                                                                                                          (expand
                                                                                                           "prime?")
                                                                                                          (("2"
                                                                                                            (ground)
                                                                                                            (("2"
                                                                                                              (lemma
                                                                                                               "posreal_times_posreal_is_posreal")
                                                                                                              (("2"
                                                                                                                (inst?)
                                                                                                                (("2"
                                                                                                                  (assert)
                                                                                                                  nil
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (hide
                                                                               2)
                                                                              (("2"
                                                                                (replace
                                                                                 -9
                                                                                 +)
                                                                                (("2"
                                                                                  (hide
                                                                                   -)
                                                                                  (("2"
                                                                                    (grind)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (split +)
                                                            (("1"
                                                              (expand
                                                               "f1"
                                                               +)
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (lemma
                                                                   "prime_divides")
                                                                  (("1"
                                                                    (case
                                                                     "FORALL (i:int,p:(prime?)): divides(p,i^2) IMPLIES divides(p,i)")
                                                                    (("1"
                                                                      (reveal
                                                                       "integerpredlem")
                                                                      (("1"
                                                                        (inst?)
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (inst
                                                                             -
                                                                             "a*pp-b*qq"
                                                                             "ps")
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil)
                                                                             ("2"
                                                                              (typepred
                                                                               "ps")
                                                                              (("2"
                                                                                (expand
                                                                                 "prime_sum_of_two_squares?")
                                                                                (("2"
                                                                                  (ground)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (hide-all-but
                                                                       (-1
                                                                        1))
                                                                      (("2"
                                                                        (skosimp*)
                                                                        (("2"
                                                                          (case
                                                                           "i!1>=0")
                                                                          (("1"
                                                                            (inst
                                                                             -
                                                                             "i!1"
                                                                             "i!1"
                                                                             "p!1")
                                                                            (("1"
                                                                              (expand
                                                                               "^")
                                                                              (("1"
                                                                                (expand
                                                                                 "expt")
                                                                                (("1"
                                                                                  (expand
                                                                                   "expt")
                                                                                  (("1"
                                                                                    (expand
                                                                                     "expt")
                                                                                    (("1"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (inst
                                                                             -
                                                                             "-i!1"
                                                                             "-i!1"
                                                                             "p!1")
                                                                            (("2"
                                                                              (expand
                                                                               "^")
                                                                              (("2"
                                                                                (expand
                                                                                 "expt")
                                                                                (("2"
                                                                                  (expand
                                                                                   "expt")
                                                                                  (("2"
                                                                                    (expand
                                                                                     "expt")
                                                                                    (("2"
                                                                                      (assert)
                                                                                      (("2"
                                                                                        (reveal
                                                                                         "intlem")
                                                                                        (("2"
                                                                                          (inst
                                                                                           -
                                                                                           "p!1"
                                                                                           "i!1")
                                                                                          (("2"
                                                                                            (ground)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (assert)
                                                              (("2"
                                                                (expand
                                                                 "f2"
                                                                 +)
                                                                (("2"
                                                                  (reveal
                                                                   "integerpredlem")
                                                                  (("2"
                                                                    (inst?)
                                                                    (("2"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (reveal
                                                       "integerpredlem")
                                                      (("2"
                                                        (inst?)
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (typepred
                                                             "ps")
                                                            (("2"
                                                              (expand
                                                               "prime_sum_of_two_squares?")
                                                              (("2"
                                                                (expand
                                                                 "prime?")
                                                                (("2"
                                                                  (flatten)
                                                                  (("2"
                                                                    (cross-mult
                                                                     1)
                                                                    (("2"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (lemma "prime_divides")
                                              (("2"
                                                (case
                                                 "FORALL (i:int,p:(prime?)): divides(p,i^2) IMPLIES divides(p,i)")
                                                (("1"
                                                  (inst
                                                   -
                                                   "a*pp-b*qq"
                                                   "ps")
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (hide -2)
                                                      (("1"
                                                        (hide -2)
                                                        (("1"
                                                          (expand
                                                           "divides"
                                                           (-1 1))
                                                          (("1"
                                                            (skosimp*)
                                                            (("1"
                                                              (inst
                                                               +
                                                               "x!1^2")
                                                              (("1"
                                                                (replace
                                                                 -1)
                                                                (("1"
                                                                  (hide-all-but
                                                                   1)
                                                                  (("1"
                                                                    (grind)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (typepred "ps")
                                                    (("2"
                                                      (expand
                                                       "prime_sum_of_two_squares?")
                                                      (("2"
                                                        (ground)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (hide-all-but (-1 1))
                                                  (("2"
                                                    (skosimp*)
                                                    (("2"
                                                      (case "i!1>=0")
                                                      (("1"
                                                        (inst
                                                         -
                                                         "i!1"
                                                         "i!1"
                                                         "p!1")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (grind
                                                             :exclude
                                                             ("divides"))
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (inst
                                                         -
                                                         "-i!1"
                                                         "-i!1"
                                                         "p!1")
                                                        (("2"
                                                          (reveal
                                                           "intlem")
                                                          (("2"
                                                            (inst
                                                             -
                                                             "p!1"
                                                             "i!1")
                                                            (("2"
                                                              (grind
                                                               :exclude
                                                               ("divides"))
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (assert)
                                            (("2"
                                              (lemma "divides_sum")
                                              (("2"
                                                (inst
                                                 -
                                                 "ns*ps"
                                                 "-(a*qq+b*pp)^2"
                                                 "ps")
                                                (("2"
                                                  (split -)
                                                  (("1"
                                                    (replace -3 -1)
                                                    (("1"
                                                      (replace -4 -1)
                                                      (("1"
                                                        (grind
                                                         :exclude
                                                         ("divides"
                                                          "sum_of_two_squares?"))
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (hide-all-but
                                                     (-1 1))
                                                    (("2"
                                                      (expand
                                                       "divides")
                                                      (("2"
                                                        (skosimp*)
                                                        (("2"
                                                          (inst
                                                           +
                                                           "-x!1*(pp*b+a*qq)")
                                                          (("2"
                                                            (grind)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("3"
                                                    (hide-all-but 1)
                                                    (("3"
                                                      (expand
                                                       "divides")
                                                      (("3"
                                                        (inst?)
                                                        (("3"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (typepred "ps")
                                    (("2"
                                      (expand
                                       "prime_sum_of_two_squares?")
                                      (("2" (ground) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (expand "divides")
                                (("2"
                                  (skosimp*)
                                  (("2"
                                    (inst + "pp^2*x!1-a^2")
                                    (("2"
                                      (hide 2)
                                      (("2" (grind) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (expand "prime_sum_of_two_squares?")
                        (("2" (expand "sum_of_two_squares?")
                          (("2" (flatten)
                            (("2" (skosimp*)
                              (("2"
                                (inst + "a!2" "b!2" "a!1" "b!1")
                                (("2"
                                  (hide (-1 -4 2))
                                  (("2" (grind) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (hide 2)
            (("2"
              (case "FORALL (rr, rs: int): divides(rr, rs) IMPLIES divides(rr, -rs)")
              (("1" (skeep)
                (("1" (ground)
                  (("1" (inst?) (("1" (assertnil nil)) nil)
                   ("2" (inst - "rr" "-rs") (("2" (assertnil nil))
                    nil))
                  nil))
                nil)
               ("2" (hide 2)
                (("2" (skeep)
                  (("2" (expand "divides")
                    (("2" (skosimp*)
                      (("2" (inst + "-x!1") (("2" (assertnil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil)
     ("2" (hide 2)
      (("2" (skeep)
        (("2" (expand "divides")
          (("2" (skosimp*)
            (("2" (case "rs/rr=x!1")
              (("1" (assert)
                (("1" (replace -1) (("1" (assertnil nil)) nil)) nil)
               ("2" (cross-mult 1) (("2" (assertnil nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((minus_int_is_int application-judgement "int" integers nil)
    (IFF const-decl "[bool, bool -> bool]" booleans nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (sum_of_two_squares? const-decl "bool" primes_sum_squares nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (^ const-decl "real" exponentiation nil)
    (nat_exp application-judgement "nat" exponentiation nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (prime? const-decl "bool" primes "ints/")
    (ps skolem-const-decl "(prime_sum_of_two_squares?)"
        primes_sum_squares nil)
    (f2 skolem-const-decl "rat" primes_sum_squares nil)
    (f1 skolem-const-decl "rat" primes_sum_squares nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (rat nonempty-type-eq-decl nil rationals nil)
    (sots_int_def formula-decl nil primes_sum_squares nil)
    (div_mult_pos_ge1 formula-decl nil real_props nil)
    (int_exp application-judgement "int" exponentiation nil)
    (sots_int? const-decl "bool" primes_sum_squares nil)
    (rat_exp application-judgement "rat" exponentiation nil)
    (expt def-decl "real" exponentiation nil)
    (int_expt application-judgement "int" exponentiation nil)
    (nzrat_div_nzrat_is_nzrat application-judgement "nzrat" rationals
     nil)
    (nat_expt application-judgement "nat" exponentiation nil)
    (rat_plus_rat_is_rat application-judgement "rat" rationals nil)
    (rat_expt application-judgement "rat" exponentiation nil)
    (rat_times_rat_is_rat application-judgement "rat" rationals nil)
    (posreal_times_posreal_is_posreal judgement-tcc nil real_types nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (> const-decl "bool" reals nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (div_cancel3 formula-decl nil real_props nil)
    (times_div2 formula-decl nil real_props nil)
    (nonzero_times3 formula-decl nil real_props nil)
    (div_times formula-decl nil real_props nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (both_sides_times1 formula-decl nil real_props nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (f2 skolem-const-decl "rat" primes_sum_squares nil)
    (f1 skolem-const-decl "rat" primes_sum_squares nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (ns skolem-const-decl "(sum_of_two_squares?)" primes_sum_squares
     nil)
    (divides_sum formula-decl nil divides nil)
    (prime_divides formula-decl nil primes_sum_squares nil)
    (prime_sum_of_two_squares? const-decl "bool" primes_sum_squares
     nil)
    (rat_div_nzrat_is_rat application-judgement "rat" rationals nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans 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)
    (/= const-decl "boolean" notequal nil)
    (nzint nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (divides const-decl "bool" divides nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil))
   shostak))
 (sots_div_quot_factor_TCC1 0
  (sots_div_quot_factor_TCC1-1 nil 3502100866
   ("" (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)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (^ const-decl "real" exponentiation nil)
    (sum_of_two_squares? const-decl "bool" primes_sum_squares nil)
    (divides const-decl "bool" divides nil)
    (/= const-decl "boolean" notequal nil)
    (nat_expt application-judgement "nat" exponentiation nil))
   nil))
 (sots_div_quot_factor_TCC2 0
  (sots_div_quot_factor_TCC2-1 nil 3502100866
   ("" (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)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (^ const-decl "real" exponentiation nil)
    (sum_of_two_squares? const-decl "bool" primes_sum_squares nil)
    (divides const-decl "bool" divides nil)
    (nat_expt application-judgement "nat" exponentiation nil)
    (rat_div_nzrat_is_rat application-judgement "rat" rationals nil))
   nil))
 (sots_div_quot_factor 0
  (sots_div_quot_factor-1 nil 3502100866
   (""
    (case "FORALL (iii,jjj:int): integer_pred(iii*jjj) and rational_pred(iii*jjj) and rational_pred(iii)")
    (("1" (label "intlem" -1)
      (("1" (hide "intlem")
        (("1" (skeep)
          (("1" (case "ns /= 0")
            (("1" (label "nsnz" -1)
              (("1" (hide "nsnz")
                (("1" (expand "divides" -)
                  (("1" (skolem -2 "rr")
                    (("1" (lemma "prime_factors")
                      (("1" (inst - "rr")
                        (("1" (skosimp*)
                          (("1" (replace -1)
                            (("1" (expand "product " -4)
                              (("1"
                                (lift-if)
                                (("1"
                                  (ground)
                                  (("1"
                                    (expand "ordered_list_of_primes?")
                                    (("1"
                                      (flatten)
                                      (("1"
                                        (expand "list_of_primes?")
                                        (("1"
                                          (case
                                           "FORALL (jj:nat,zz:nat): jj+zz<=length(fs!1)-1 IMPLIES m*product[nat](jj,jj+zz,fs!1`seq)>0")
                                          (("1"
                                            (label "prodposm" -1)
                                            (("1"
                                              (hide "prodposm")
                                              (("1"
                                                (case
                                                 "FORALL (ii:nat): ii<=length(fs!1) IMPLIES sum_of_two_squares?(m * product(0, length(fs!1) - 1-ii, fs!1`seq))")
                                                (("1"
                                                  (inst
                                                   -
                                                   "length(fs!1)")
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (induct "ii")
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil)
                                                   ("2"
                                                    (skeep)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (expand
                                                         "product"
                                                         -1)
                                                        (("2"
                                                          (lemma
                                                           "sots_div_prime_closed")
                                                          (("2"
                                                            (inst
                                                             -
                                                             "m *
                                                                                                                                                       (fs!1`seq(length(fs!1) - 1 - j) *
                                                                                                                                                         product(0, length(fs!1) - 2 - j, fs!1`seq))"
                                                             "fs!1`seq(length(fs!1) - 1 - j)")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (expand
                                                                 "divides"
                                                                 1)
                                                                (("1"
                                                                  (inst
                                                                   +
                                                                   "m *
                                                                                                                                               product(0, length(fs!1) - 2 - j, fs!1`seq)")
                                                                  (("1"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (expand
                                                               "prime_sum_of_two_squares?")
                                                              (("2"
                                                                (case
                                                                 "prime?(fs!1`seq(length(fs!1) - 1 - j))")
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (inst
                                                                     +
                                                                     "fs!1`seq(length(fs!1) - 1 - j)")
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (expand
                                                                         "divides"
                                                                         +)
                                                                        (("1"
                                                                          (inst
                                                                           +
                                                                           "product[nat](0,length(fs!1) - 2 - j,fs!1`seq)*product(length(fs!1)-j,length(fs!1)-1,fs!1`seq)")
                                                                          (("1"
                                                                            (case
                                                                             "fs!1`seq(length(fs!1) - 1 - j) *
                                                                                                                                                       (product[nat](0, length(fs!1) - 2 - j, fs!1`seq) *
                                                                                                                                                         product(length(fs!1) - j, length(fs!1) - 1, fs!1`seq)) = product(0, length(fs!1) - 1, fs!1`seq)")
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil)
                                                                             ("2"
                                                                              (hide-all-but
                                                                               1)
                                                                              (("2"
                                                                                (lemma
                                                                                 "product_split")
                                                                                (("2"
                                                                                  (inst
                                                                                   -
                                                                                   "fs!1`seq"
                                                                                   "length(fs!1)-1"
                                                                                   "0"
                                                                                   "length(fs!1)-1-j")
                                                                                  (("2"
                                                                                    (assert)
                                                                                    (("2"
                                                                                      (expand
                                                                                       "product"
                                                                                       -
                                                                                       2)
                                                                                      (("2"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (reveal
                                                                   "intlem")
                                                                  (("2"
                                                                    (inst?)
                                                                    (("2"
                                                                      (assert)
                                                                      (("2"
                                                                        (flatten)
                                                                        (("2"
                                                                          (hide
                                                                           2)
                                                                          (("2"
                                                                            (inst
                                                                             -5
                                                                             "length(fs!1)-1-j")
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("3"
                                                    (assert)
                                                    (("3"
                                                      (skeep)
                                                      (("3"
                                                        (inst + "2")
                                                        (("3"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("4"
                                                    (assert)
                                                    (("4"
                                                      (skosimp*)
                                                      (("4"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("3"
                                                  (assert)
                                                  (("3"
                                                    (skosimp*)
                                                    (("3"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (induct "zz")
                                            (("1"
                                              (assert)
                                              (("1"
                                                (skeep)
                                                (("1"
                                                  (expand "product" +)
                                                  (("1"
                                                    (expand
                                                     "product"
                                                     +)
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (typepred
                                                         "fs!1`seq(jj)")
                                                        (("1"
                                                          (mult-by
                                                           -1
                                                           "m")
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (skolem 1 "zz")
                                              (("2"
                                                (flatten)
                                                (("2"
                                                  (skeep)
                                                  (("2"
                                                    (inst - "jj")
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (expand
                                                         "product"
                                                         +)
                                                        (("2"
                                                          (mult-by
                                                           -1
                                                           "fs!1`seq(1+jj+zz)")
                                                          (("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (assert)
                          (("2" (case "rr>0")
                            (("1" (assertnil nil)
                             ("2" (hide 2)
                              (("2"
                                (case "rr = ns/m")
                                (("1"
                                  (replace -1 +)
                                  (("1"
                                    (hide -1)
                                    (("1"
                                      (cross-mult 1)
                                      (("1"
                                        (reveal "nsnz")
                                        (("1" (assertnil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2" (cross-mult 1) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (flatten)
              (("2" (replace -1)
                (("2" (inst + "m") (("2" (assertnil nil)) nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil)
     ("2" (hide 2) (("2" (skeep) (("2" (assertnil nil)) nil)) nil))
    nil)
   ((divides const-decl "bool" divides nil)
    (prime_factors formula-decl nil prime_factorization nil)
    (div_cancel4 formula-decl nil real_props nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (div_mult_pos_gt1 formula-decl nil extra_real_props nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (product const-decl "posnat" product_fseq_posnat "reals/")
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (prod_nnr application-judgement "nnreal" product_nat "reals/")
    (int_minus_int_is_int application-judgement "int" integers 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)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (barray type-eq-decl nil fseqs "structures/")
    (fseq type-eq-decl nil fseqs "structures/")
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (T_low type-eq-decl nil product "reals/")
    (T_high type-eq-decl nil product "reals/")
    (product def-decl "real" product "reals/")
    (fs!1 skolem-const-decl "fseq[posnat]" primes_sum_squares nil)
    (pred type-eq-decl nil defined_types nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (below type-eq-decl nil naturalnumbers nil)
    (ii!1 skolem-const-decl "nat" primes_sum_squares nil)
    (< const-decl "bool" reals nil)
    (prod_posnat application-judgement "posnat" product_nat "reals/")
    (prod_pr application-judgement "posreal" product_nat "reals/")
    (prod_nat application-judgement "nat" product_nat "reals/")
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (sots_div_prime_closed formula-decl nil primes_sum_squares nil)
    (rat_div_nzrat_is_rat application-judgement "rat" rationals nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (product_split formula-decl nil product "reals/")
    (= const-decl "[T, T -> boolean]" equalities nil)
    (prime? const-decl "bool" primes "ints/")
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (prime_sum_of_two_squares? const-decl "bool" primes_sum_squares
     nil)
    (j skolem-const-decl "nat" primes_sum_squares nil)
    (m skolem-const-decl "nat" primes_sum_squares nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (product_0_neg formula-decl nil product_nat "reals/")
    (product_nat_nat application-judgement "posnat" product_fseq_posnat
     "reals/")
    (both_sides_times_pos_gt1 formula-decl nil real_props nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (list_of_primes? const-decl "bool" prime_factorization nil)
    (ordered_list_of_primes? const-decl "bool" prime_factorization nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (rr skolem-const-decl "int" primes_sum_squares 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)
    (sum_of_two_squares? const-decl "bool" primes_sum_squares nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (/= const-decl "boolean" notequal nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans 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)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields
       nil))
   shostak))
 (rel_prime_sos_factor_TCC1 0
  (rel_prime_sos_factor_TCC1-1 nil 3502105281
   ("" (subtype-tcc) nil nilnil nil))
 (rel_prime_sos_factor_TCC2 0
  (rel_prime_sos_factor_TCC2-1 nil 3502105281
   ("" (subtype-tcc) nil nil)
   ((divides const-decl "bool" divides nil)
    (gcd const-decl "{k: posnat | divides(k, i) AND divides(k, j)}" gcd
         "ints/")
    (rel_prime const-decl "bool" gcd "ints/"))
   nil))
 (rel_prime_sos_factor_TCC3 0
  (rel_prime_sos_factor_TCC3-1 nil 3502105281
   ("" (subtype-tcc) nil nil)
   ((divides const-decl "bool" divides nil)
    (gcd const-decl "{k: posnat | divides(k, i) AND divides(k, j)}" gcd
         "ints/")
    (rel_prime const-decl "bool" gcd "ints/"))
   nil))
 (rel_prime_sos_factor 0
  (rel_prime_sos_factor-2 "" 3539699252
   (""
    (case "FORALL (m:nat, n: nat, pa, pb: int): n<=m AND
                                                                              (NOT (pa=0 AND pb=0)) AND rel_prime(pa, pb) AND divides(n, pa ^ 2 + pb ^ 2) IMPLIES
                                                                               sum_of_two_squares?(n)")
    (("1" (skeep)
      (("1" (inst - "n" "n" "pa" "pb") (("1" (assertnil nil)) nil))
      nil)
     ("2" (hide 2)
      (("2" (induct "m")
        (("1" (skeep)
          (("1" (case "n = 0")
            (("1" (replace -1)
              (("1" (hide -)
                (("1" (expand "sum_of_two_squares?")
                  (("1" (inst + "0" "0") (("1" (grind) nil nil)) nil))
                  nil))
                nil))
              nil)
             ("2" (assertnil nil))
            nil))
          nil)
         ("2" (skeep)
          (("2" (skeep)
            (("2" (label "papbnz" 1)
              (("2" (case "NOT j = n-1")
                (("1" (inst - "n" "pa" "pb") (("1" (assertnil nil))
                  nil)
                 ("2" (hide "papbnz")
                  (("2" (replace -1)
                    (("2" (hide -3)
                      (("2" (name "xx" "n")
                        (("2" (replace -1)
                          (("2" (case "xx > 0")
                            (("1" (label "xxpos" -1)
                              (("1"
                                (hide "xxpos")
                                (("1"
                                  (label "hyp" -3)
                                  (("1"
                                    (hide (-1 -2))
                                    (("1"
                                      (hide "hyp")
                                      (("1"
                                        (case
                                         "divides(xx,pa) AND divides(xx,pb)")
                                        (("1"
                                          (flatten)
                                          (("1"
                                            (lemma "divides_gcd")
                                            (("1"
                                              (inst - "pa" "pb" "xx")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (expand "rel_prime")
                                                  (("1"
                                                    (replace -4)
                                                    (("1"
                                                      (case "xx = 1")
                                                      (("1"
                                                        (replace -1)
                                                        (("1"
                                                          (hide -)
                                                          (("1"
                                                            (expand
                                                             "sum_of_two_squares?")
                                                            (("1"
                                                              (inst
                                                               +
                                                               "0"
                                                               "1")
                                                              (("1"
                                                                (grind)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (hide-all-but
                                                         (-1 1))
                                                        (("2"
                                                          (reveal
                                                           "papbnz")
                                                          (("2"
                                                            (split -)
                                                            (("1"
                                                              (expand
                                                               "divides")
                                                              (("1"
                                                                (skosimp*)
                                                                (("1"
                                                                  (case
                                                                   "x!1 > 1")
                                                                  (("1"
                                                                    (mult-by
                                                                     -1
                                                                     "xx")
                                                                    (("1"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (case
                                                                     "x!1 = 1")
                                                                    (("1"
                                                                      (assert)
                                                                      nil
                                                                      nil)
                                                                     ("2"
                                                                      (lemma
                                                                       "posreal_times_posreal_is_posreal")
                                                                      (("2"
                                                                        (inst
                                                                         -
                                                                         "-x!1"
                                                                         "xx")
                                                                        (("1"
                                                                          (assert)
                                                                          nil
                                                                          nil)
                                                                         ("2"
                                                                          (assert)
                                                                          nil
                                                                          nil)
                                                                         ("3"
                                                                          (ground)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (ground)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (assert)
                                                (("2"
                                                  (flatten)
                                                  (("2"
                                                    (replace -1)
                                                    (("2"
                                                      (hide -)
                                                      (("2"
                                                        (expand
                                                         "sum_of_two_squares?")
                                                        (("2"
                                                          (inst
                                                           +
                                                           "0"
                                                           "0")
                                                          (("2"
                                                            (grind)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (label "xxdivpapb" 1)
                                          (("2"
                                            (hide "xxdivpapb")
                                            (("2"
                                              (label "divxx" -2)
                                              (("2"
                                                (label "papbrp" -1)
                                                (("2"
                                                  (case
                                                   "EXISTS (cc,dd:int,mm,nn:int): abs(cc)<=xx/2 AND abs(dd)<=xx/2 AND pa = mm*xx+cc AND pb = nn*xx+dd")
                                                  (("1"
                                                    (skeep -1)
                                                    (("1"
                                                      (label
                                                       "ccabs"
                                                       -1)
                                                      (("1"
                                                        (label
                                                         "ddabs"
                                                         -2)
                                                        (("1"
                                                          (label
                                                           "ccdef"
                                                           -3)
                                                          (("1"
                                                            (label
                                                             "dddef"
                                                             -4)
                                                            (("1"
                                                              (case
                                                               "(cc = 0 AND dd = 0)")
                                                              (("1"
                                                                (flatten)
                                                                (("1"
                                                                  (replace
                                                                   -1)
                                                                  (("1"
                                                                    (replace
                                                                     -2)
                                                                    (("1"
                                                                      (reveal
                                                                       "xxdivpapb")
                                                                      (("1"
                                                                        (expand
                                                                         "divides"
                                                                         +)
                                                                        (("1"
                                                                          (split
                                                                           +)
                                                                          (("1"
                                                                            (inst
                                                                             +
                                                                             "mm")
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (inst
                                                                             +
                                                                             "nn")
                                                                            (("2"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (label
                                                                 "ccddnz"
                                                                 1)
                                                                (("2"
                                                                  (hide
                                                                   "ccddnz")
                                                                  (("2"
                                                                    (case
                                                                     "EXISTS (AA:int): pa^2 + pb^2 = AA*xx + (cc^2 + dd^2)")
                                                                    (("1"
                                                                      (label
                                                                       "AAdef"
                                                                       -1)
                                                                      (("1"
                                                                        (skeep
                                                                         -1)
                                                                        (("1"
                                                                          (case
                                                                           "NOT rel_prime(gcd(cc,dd),xx)")
                                                                          (("1"
                                                                            (expand
                                                                             "rel_prime"
                                                                             +)
                                                                            (("1"
                                                                              (case
                                                                               "divides(gcd(cc,dd),pa) AND divides(gcd(cc,dd),pb)")
                                                                              (("1"
                                                                                (flatten)
                                                                                (("1"
                                                                                  (lemma
                                                                                   "divides_gcd")
                                                                                  (("1"
                                                                                    (inst
                                                                                     -
                                                                                     "pa"
                                                                                     "pb"
                                                                                     "gcd(cc,dd)")
                                                                                    (("1"
                                                                                      (assert)
                                                                                      (("1"
                                                                                        (split
                                                                                         -1)
                                                                                        (("1"
                                                                                          (expand
                                                                                           "rel_prime")
                                                                                          (("1"
                                                                                            (replace
                                                                                             "papbrp")
                                                                                            (("1"
                                                                                              (assert)
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "divides"
                                                                                                 -1)
                                                                                                (("1"
                                                                                                  (skosimp*)
                                                                                                  (("1"
                                                                                                    (case
                                                                                                     "x!1 > 1")
                                                                                                    (("1"
                                                                                                      (mult-by
                                                                                                       -1
                                                                                                       "gcd(cc,dd)")
                                                                                                      (("1"
                                                                                                        (assert)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (case
                                                                                                       "x!1 = 1")
                                                                                                      (("1"
                                                                                                        (replace
                                                                                                         -1)
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          (("1"
                                                                                                            (replace
                                                                                                             -2
                                                                                                             :dir
                                                                                                             rl)
                                                                                                            (("1"
                                                                                                              (assert)
                                                                                                              (("1"
                                                                                                                (hide-all-but
                                                                                                                 2)
                                                                                                                (("1"
                                                                                                                  (typepred
                                                                                                                   "gcd(1,xx)")
                                                                                                                  (("1"
                                                                                                                    (hide
                                                                                                                     (-1
                                                                                                                      -3))
                                                                                                                    (("1"
                                                                                                                      (expand
                                                                                                                       "divides")
                                                                                                                      (("1"
                                                                                                                        (skosimp*)
                                                                                                                        (("1"
                                                                                                                          (case
                                                                                                                           "x!2 > 1")
                                                                                                                          (("1"
                                                                                                                            (mult-by
                                                                                                                             -1
                                                                                                                             "gcd(1,xx)")
                                                                                                                            (("1"
                                                                                                                              (assert)
                                                                                                                              nil
                                                                                                                              nil))
                                                                                                                            nil)
                                                                                                                           ("2"
                                                                                                                            (case
                                                                                                                             "x!2 = 1")
                                                                                                                            (("1"
                                                                                                                              (assert)
                                                                                                                              nil
                                                                                                                              nil)
                                                                                                                             ("2"
                                                                                                                              (assert)
                                                                                                                              (("2"
                                                                                                                                (case
                                                                                                                                 "x!2 < 0")
                                                                                                                                (("1"
                                                                                                                                  (lemma
                                                                                                                                   "posreal_times_posreal_is_posreal")
                                                                                                                                  (("1"
                                                                                                                                    (inst
                                                                                                                                     -
                                                                                                                                     "-x!2"
                                                                                                                                     "gcd(1,xx)")
                                                                                                                                    (("1"
                                                                                                                                      (assert)
                                                                                                                                      nil
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil)
                                                                                                                                 ("2"
                                                                                                                                  (assert)
                                                                                                                                  nil
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil)
                                                                                                       ("2"
                                                                                                        (assert)
                                                                                                        (("2"
                                                                                                          (lemma
                                                                                                           "posreal_times_posreal_is_posreal")
                                                                                                          (("2"
                                                                                                            (inst
                                                                                                             -
                                                                                                             "-x!1"
                                                                                                             "gcd(cc,dd)")
                                                                                                            (("2"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (reveal
                                                                                           "papbnz")
                                                                                          (("2"
                                                                                            (ground)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (case
                                                                                 "FORALL (ab1,mn1,cd1,dg1:int): divides(dg1,cd1) AND divides(dg1,xx) AND ab1 = mn1*xx + cd1 IMPLIES divides(dg1,ab1)")
                                                                                (("1"
                                                                                  (inst-cp
                                                                                   -
                                                                                   "pa"
                                                                                   "mm"
                                                                                   "cc"
                                                                                   "gcd(gcd(cc,dd),xx)")
                                                                                  (("1"
                                                                                    (inst
                                                                                     -
                                                                                     "pb"
                                                                                     "nn"
                                                                                     "dd"
                                                                                     "gcd(gcd(cc,dd),xx)")
                                                                                    (("1"
                                                                                      (assert)
                                                                                      (("1"
                                                                                        (case
                                                                                         "FORALL (rrz,xxz,ccz:int): divides(rrz,xxz) AND divides(xxz,ccz) IMPLIES divides(rrz,ccz)")
                                                                                        (("1"
                                                                                          (split
                                                                                           -)
                                                                                          (("1"
                                                                                            (split
                                                                                             -)
                                                                                            (("1"
                                                                                              (hide
                                                                                               -3)
                                                                                              (("1"
                                                                                                (assert)
                                                                                                (("1"
                                                                                                  (copy
                                                                                                   "papbrp")
                                                                                                  (("1"
                                                                                                    (expand
                                                                                                     "rel_prime"
                                                                                                     -1)
                                                                                                    (("1"
                                                                                                      (lemma
                                                                                                       "divides_gcd")
                                                                                                      (("1"
                                                                                                        (inst
                                                                                                         -
                                                                                                         "pa"
                                                                                                         "pb"
                                                                                                         "gcd(gcd(cc,dd),xx)")
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          (("1"
                                                                                                            (split
                                                                                                             -1)
                                                                                                            (("1"
                                                                                                              (replace
                                                                                                               -2)
                                                                                                              (("1"
                                                                                                                (hide-all-but
                                                                                                                 (-1
                                                                                                                  2))
                                                                                                                (("1"
                                                                                                                  (expand
                                                                                                                   "divides")
                                                                                                                  (("1"
                                                                                                                    (skosimp*)
                                                                                                                    (("1"
                                                                                                                      (case
                                                                                                                       "x!1 > 1")
                                                                                                                      (("1"
                                                                                                                        (mult-by
                                                                                                                         -1
                                                                                                                         "gcd(gcd(cc,dd),xx)")
                                                                                                                        (("1"
                                                                                                                          (assert)
                                                                                                                          nil
                                                                                                                          nil))
                                                                                                                        nil)
                                                                                                                       ("2"
                                                                                                                        (case
                                                                                                                         "x!1 = 1")
                                                                                                                        (("1"
                                                                                                                          (replace
                                                                                                                           -1)
                                                                                                                          (("1"
                                                                                                                            (assert)
                                                                                                                            nil
                                                                                                                            nil))
                                                                                                                          nil)
                                                                                                                         ("2"
                                                                                                                          (lemma
                                                                                                                           "posreal_times_posreal_is_posreal")
                                                                                                                          (("2"
                                                                                                                            (inst
                                                                                                                             -
                                                                                                                             "-x!1"
                                                                                                                             "gcd(gcd(cc,dd),xx)")
                                                                                                                            (("1"
                                                                                                                              (assert)
                                                                                                                              nil
                                                                                                                              nil)
                                                                                                                             ("2"
                                                                                                                              (ground)
                                                                                                                              nil
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil)
                                                                                                             ("2"
                                                                                                              (reveal
                                                                                                               "papbnz")
                                                                                                              (("2"
                                                                                                                (ground)
                                                                                                                nil
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil)
                                                                                             ("2"
                                                                                              (hide-all-but
                                                                                               (-2
                                                                                                1))
                                                                                              (("2"
                                                                                                (inst
                                                                                                 -
                                                                                                 "gcd(gcd(cc,dd),xx)"
                                                                                                 "gcd(cc,dd)"
                                                                                                 "cc")
                                                                                                (("2"
                                                                                                  (assert)
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (hide-all-but
                                                                                             (-1
                                                                                              1))
                                                                                            (("2"
                                                                                              (inst
                                                                                               -
                                                                                               "gcd(gcd(cc,dd),xx)"
                                                                                               "gcd(cc,dd)"
                                                                                               "dd")
                                                                                              (("2"
                                                                                                (assert)
                                                                                                nil
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (hide-all-but
                                                                                           1)
                                                                                          (("2"
                                                                                            (skosimp*)
                                                                                            (("2"
                                                                                              (expand
                                                                                               "divides")
                                                                                              (("2"
                                                                                                (skosimp*)
                                                                                                (("2"
                                                                                                  (replace
                                                                                                   -1)
                                                                                                  (("2"
                                                                                                    (inst
                                                                                                     +
                                                                                                     "x!1*x!2")
                                                                                                    (("2"
                                                                                                      (assert)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (hide-all-but
                                                                                   1)
                                                                                  (("2"
                                                                                    (skeep)
                                                                                    (("2"
                                                                                      (expand
                                                                                       "divides")
                                                                                      (("2"
                                                                                        (skosimp*)
                                                                                        (("2"
                                                                                          (replace
                                                                                           -1)
                                                                                          (("2"
                                                                                            (replace
                                                                                             -2)
                                                                                            (("2"
                                                                                              (inst
                                                                                               +
                                                                                               "mn1*x!2 + x!1")
                                                                                              (("2"
                                                                                                (assert)
                                                                                                nil
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (case
                                                                             "divides(xx,cc^2 + dd^2)")
                                                                            (("1"
                                                                              (label
                                                                               "ccddxxrp"
                                                                               -2)
                                                                              (("1"
                                                                                (label
                                                                                 "xxccdddiv"
                                                                                 -1)
                                                                                (("1"
                                                                                  (expand
                                                                                   "divides"
                                                                                   -1)
                                                                                  (("1"
                                                                                    (skolem
                                                                                     -1
                                                                                     "yy")
                                                                                    (("1"
                                                                                      (case
                                                                                       "divides(gcd(cc,dd)^2,yy)")
                                                                                      (("1"
                                                                                        (label
                                                                                         "ccddsqyydiv"
                                                                                         -1)
                                                                                        (("1"
                                                                                          (expand
                                                                                           "divides"
                                                                                           -1)
                                                                                          (("1"
                                                                                            (skosimp*)
                                                                                            (("1"
                                                                                              (case
                                                                                               "EXISTS (ee,ff:int): ee = cc/gcd(cc,dd) AND ff = dd/gcd(cc,dd)")
                                                                                              (("1"
                                                                                                (skeep
                                                                                                 -1)
                                                                                                (("1"
                                                                                                  (label
                                                                                                   "eedef"
                                                                                                   -1)
                                                                                                  (("1"
                                                                                                    (label
                                                                                                     "ffdef"
                                                                                                     -2)
                                                                                                    (("1"
                                                                                                      (case
                                                                                                       "(ee = 0 AND ff = 0)")
                                                                                                      (("1"
                                                                                                        (reveal
                                                                                                         "ccddnz")
                                                                                                        (("1"
                                                                                                          (hide-all-but
                                                                                                           (-1
                                                                                                            -2
                                                                                                            -3
                                                                                                            1))
                                                                                                          (("1"
                                                                                                            (flatten)
                                                                                                            (("1"
                                                                                                              (replace
                                                                                                               -1)
                                                                                                              (("1"
                                                                                                                (replace
                                                                                                                 -2)
                                                                                                                (("1"
                                                                                                                  (cross-mult
                                                                                                                   -3)
                                                                                                                  (("1"
                                                                                                                    (cross-mult
                                                                                                                     -4)
                                                                                                                    (("1"
                                                                                                                      (assert)
                                                                                                                      nil
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil)
                                                                                                       ("2"
                                                                                                        (label
                                                                                                         "eeffnz"
                                                                                                         1)
                                                                                                        (("2"
                                                                                                          (case
                                                                                                           "ee^2 + ff^2 > 0")
                                                                                                          (("1"
                                                                                                            (hide
                                                                                                             "eeffnz")
                                                                                                            (("1"
                                                                                                              (label
                                                                                                               "eeffsqpos"
                                                                                                               -1)
                                                                                                              (("1"
                                                                                                                (case
                                                                                                                 "divides(xx,ee^2 + ff^2)")
                                                                                                                (("1"
                                                                                                                  (copy
                                                                                                                   -1)
                                                                                                                  (("1"
                                                                                                                    (expand
                                                                                                                     "divides"
                                                                                                                     -1)
                                                                                                                    (("1"
                                                                                                                      (skolem
                                                                                                                       -1
                                                                                                                       "zz")
                                                                                                                      (("1"
                                                                                                                        (case
                                                                                                                         "zz > 0")
                                                                                                                        (("1"
                                                                                                                          (label
                                                                                                                           "zzpos"
                                                                                                                           -1)
                                                                                                                          (("1"
                                                                                                                            (label
                                                                                                                             "zzdef"
                                                                                                                             -2)
                                                                                                                            (("1"
                                                                                                                              (case
                                                                                                                               "abs(zz) <= xx/2")
                                                                                                                              (("1"
                                                                                                                                (label
                                                                                                                                 "abszz"
                                                                                                                                 -1)
                                                                                                                                (("1"
                                                                                                                                  (case
                                                                                                                                   "rel_prime(ee,ff)")
                                                                                                                                  (("1"
                                                                                                                                    (lemma
                                                                                                                                     "sots_div_quot_factor")
                                                                                                                                    (("1"
                                                                                                                                      (inst
                                                                                                                                       -
                                                                                                                                       "xx"
                                                                                                                                       "ee^2 + ff^2")
                                                                                                                                      (("1"
                                                                                                                                        (assert)
                                                                                                                                        (("1"
                                                                                                                                          (split
                                                                                                                                           -)
                                                                                                                                          (("1"
                                                                                                                                            (skeep
                                                                                                                                             -1)
                                                                                                                                            (("1"
                                                                                                                                              (reveal
                                                                                                                                               "hyp")
                                                                                                                                              (("1"
                                                                                                                                                (inst
                                                                                                                                                 -
                                                                                                                                                 "b"
                                                                                                                                                 "ee"
                                                                                                                                                 "ff")
                                                                                                                                                (("1"
                                                                                                                                                  (assert)
                                                                                                                                                  (("1"
                                                                                                                                                    (case
                                                                                                                                                     "b <=zz")
                                                                                                                                                    (("1"
                                                                                                                                                      (assert)
                                                                                                                                                      (("1"
                                                                                                                                                        (reveal
                                                                                                                                                         "eeffnz")
                                                                                                                                                        (("1"
                                                                                                                                                          (replace
                                                                                                                                                           1)
                                                                                                                                                          (("1"
                                                                                                                                                            (hide
                                                                                                                                                             "eeffnz")
                                                                                                                                                            (("1"
                                                                                                                                                              (hide-all-but
                                                                                                                                                               (-2
                                                                                                                                                                1))
                                                                                                                                                              (("1"
                                                                                                                                                                (expand
                                                                                                                                                                 "divides")
                                                                                                                                                                (("1"
                                                                                                                                                                  (skosimp*)
                                                                                                                                                                  (("1"
                                                                                                                                                                    (cross-mult
                                                                                                                                                                     -1)
                                                                                                                                                                    (("1"
                                                                                                                                                                      (inst
                                                                                                                                                                       +
                                                                                                                                                                       "x!2*xx")
                                                                                                                                                                      (("1"
                                                                                                                                                                        (assert)
                                                                                                                                                                        nil
                                                                                                                                                                        nil))
                                                                                                                                                                      nil))
                                                                                                                                                                    nil))
                                                                                                                                                                  nil))
                                                                                                                                                                nil))
                                                                                                                                                              nil))
                                                                                                                                                            nil))
                                                                                                                                                          nil))
                                                                                                                                                        nil))
                                                                                                                                                      nil)
                                                                                                                                                     ("2"
                                                                                                                                                      (assert)
                                                                                                                                                      (("2"
                                                                                                                                                        (replace
                                                                                                                                                         "zzdef")
                                                                                                                                                        (("2"
                                                                                                                                                          (assert)
                                                                                                                                                          (("2"
                                                                                                                                                            (expand
                                                                                                                                                             "divides"
                                                                                                                                                             -1)
                                                                                                                                                            (("2"
                                                                                                                                                              (skosimp*)
                                                                                                                                                              (("2"
                                                                                                                                                                (cross-mult
                                                                                                                                                                 -1)
                                                                                                                                                                (("2"
                                                                                                                                                                  (mult-by
                                                                                                                                                                   1
                                                                                                                                                                   "xx")
                                                                                                                                                                  (("2"
                                                                                                                                                                    (case
                                                                                                                                                                     "x!2 > 1")
                                                                                                                                                                    (("1"
                                                                                                                                                                      (mult-by
                                                                                                                                                                       -1
                                                                                                                                                                       "b*xx")
                                                                                                                                                                      (("1"
                                                                                                                                                                        (assert)
                                                                                                                                                                        nil
                                                                                                                                                                        nil))
                                                                                                                                                                      nil)
                                                                                                                                                                     ("2"
                                                                                                                                                                      (case
                                                                                                                                                                       "x!2 = 1")
                                                                                                                                                                      (("1"
                                                                                                                                                                        (replace
                                                                                                                                                                         -1)
                                                                                                                                                                        (("1"
                                                                                                                                                                          (assert)
                                                                                                                                                                          nil
                                                                                                                                                                          nil))
                                                                                                                                                                        nil)
                                                                                                                                                                       ("2"
                                                                                                                                                                        (lemma
                                                                                                                                                                         "posreal_times_posreal_is_posreal")
                                                                                                                                                                        (("2"
                                                                                                                                                                          (inst
                                                                                                                                                                           -
                                                                                                                                                                           "b*xx"
                                                                                                                                                                           "-x!2")
                                                                                                                                                                          (("1"
                                                                                                                                                                            (assert)
                                                                                                                                                                            nil
                                                                                                                                                                            nil)
                                                                                                                                                                           ("2"
                                                                                                                                                                            (assert)
                                                                                                                                                                            nil
                                                                                                                                                                            nil)
                                                                                                                                                                           ("3"
                                                                                                                                                                            (assert)
                                                                                                                                                                            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
                                                                                                                                               "sum_of_two_squares?")
                                                                                                                                              (("2"
                                                                                                                                                (inst
                                                                                                                                                 +
                                                                                                                                                 "abs(ee)"
                                                                                                                                                 "abs(ff)")
                                                                                                                                                (("2"
                                                                                                                                                  (grind)
                                                                                                                                                  nil
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil)
                                                                                                                                       ("2"
                                                                                                                                        (assert)
                                                                                                                                        (("2"
                                                                                                                                          (hide-all-but
                                                                                                                                           1)
                                                                                                                                          (("2"
                                                                                                                                            (expand
                                                                                                                                             "sum_of_two_squares?")
                                                                                                                                            (("2"
                                                                                                                                              (inst
                                                                                                                                               +
                                                                                                                                               "abs(ee)"
                                                                                                                                               "abs(ff)")
                                                                                                                                              (("2"
                                                                                                                                                (grind)
                                                                                                                                                nil
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil)
                                                                                                                                   ("2"
                                                                                                                                    (hide-all-but
                                                                                                                                     (-1
                                                                                                                                      -2
                                                                                                                                      -3
                                                                                                                                      -4
                                                                                                                                      -5
                                                                                                                                      -6
                                                                                                                                      -7
                                                                                                                                      "eedef"
                                                                                                                                      "ffdef"
                                                                                                                                      1))
                                                                                                                                    (("2"
                                                                                                                                      (lemma
                                                                                                                                       "gcd_factors")
                                                                                                                                      (("2"
                                                                                                                                        (inst
                                                                                                                                         -
                                                                                                                                         "cc"
                                                                                                                                         "dd")
                                                                                                                                        (("2"
                                                                                                                                          (assert)
                                                                                                                                          (("2"
                                                                                                                                            (reveal
                                                                                                                                             "ccddnz")
                                                                                                                                            (("2"
                                                                                                                                              (split
                                                                                                                                               -1)
                                                                                                                                              (("1"
                                                                                                                                                (hide
                                                                                                                                                 "ccddnz")
                                                                                                                                                (("1"
                                                                                                                                                  (skosimp*)
                                                                                                                                                  (("1"
                                                                                                                                                    (rewrite
                                                                                                                                                     "rel_prime_lem")
                                                                                                                                                    (("1"
                                                                                                                                                      (inst
                                                                                                                                                       +
                                                                                                                                                       "jp!1"
                                                                                                                                                       "ip!1")
                                                                                                                                                      (("1"
                                                                                                                                                        (mult-by
                                                                                                                                                         1
                                                                                                                                                         "gcd(cc,dd)")
                                                                                                                                                        (("1"
                                                                                                                                                          (assert)
                                                                                                                                                          nil
                                                                                                                                                          nil))
                                                                                                                                                        nil))
                                                                                                                                                      nil)
                                                                                                                                                     ("2"
                                                                                                                                                      (reveal
                                                                                                                                                       "eeffnz")
                                                                                                                                                      (("2"
                                                                                                                                                        (ground)
                                                                                                                                                        nil
                                                                                                                                                        nil))
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil)
                                                                                                                                               ("2"
                                                                                                                                                (ground)
                                                                                                                                                nil
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil)
                                                                                                                                   ("3"
                                                                                                                                    (reveal
                                                                                                                                     "eeffnz")
                                                                                                                                    (("3"
                                                                                                                                      (ground)
                                                                                                                                      nil
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil)
                                                                                                                               ("2"
                                                                                                                                (case
                                                                                                                                 "xx*zz <= xx^2/2")
                                                                                                                                (("1"
                                                                                                                                  (case
                                                                                                                                   "zz <= xx/2")
                                                                                                                                  (("1"
                                                                                                                                    (case
                                                                                                                                     "zz>=0")
                                                                                                                                    (("1"
                                                                                                                                      (hide-all-but
                                                                                                                                       (-1
                                                                                                                                        -2
                                                                                                                                        1))
                                                                                                                                      (("1"
                                                                                                                                        (grind)
                                                                                                                                        nil
                                                                                                                                        nil))
                                                                                                                                      nil)
                                                                                                                                     ("2"
                                                                                                                                      (assert)
                                                                                                                                      nil
                                                                                                                                      nil))
                                                                                                                                    nil)
                                                                                                                                   ("2"
                                                                                                                                    (reveal
                                                                                                                                     "xxpos")
                                                                                                                                    (("2"
                                                                                                                                      (hide-all-but
                                                                                                                                       (-1
                                                                                                                                        -2
                                                                                                                                        1))
                                                                                                                                      (("2"
                                                                                                                                        (mult-by
                                                                                                                                         1
                                                                                                                                         "xx")
                                                                                                                                        (("2"
                                                                                                                                          (grind)
                                                                                                                                          nil
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil)
                                                                                                                                 ("2"
                                                                                                                                  (case
                                                                                                                                   "ee^2 <= cc^2 AND ff^2 <= dd^2 AND cc^2<=xx^2/4 AND dd^2 <= xx^2/4")
                                                                                                                                  (("1"
                                                                                                                                    (flatten)
                                                                                                                                    (("1"
                                                                                                                                      (assert)
                                                                                                                                      nil
                                                                                                                                      nil))
                                                                                                                                    nil)
                                                                                                                                   ("2"
                                                                                                                                    (case
                                                                                                                                     "gcd(cc,dd)^2 >=1")
                                                                                                                                    (("1"
                                                                                                                                      (split
                                                                                                                                       +)
                                                                                                                                      (("1"
                                                                                                                                        (replace
                                                                                                                                         "eedef"
                                                                                                                                         1)
                                                                                                                                        (("1"
                                                                                                                                          (rewrite
                                                                                                                                           "div_expt")
                                                                                                                                          (("1"
                                                                                                                                            (cross-mult
                                                                                                                                             1)
                                                                                                                                            (("1"
                                                                                                                                              (mult-by
                                                                                                                                               -1
                                                                                                                                               "cc^2")
                                                                                                                                              (("1"
                                                                                                                                                (assert)
                                                                                                                                                nil
                                                                                                                                                nil)
                                                                                                                                               ("2"
                                                                                                                                                (hide-all-but
                                                                                                                                                 1)
                                                                                                                                                (("2"
                                                                                                                                                  (lemma
                                                                                                                                                   "nnreal_times_nnreal_is_nnreal")
                                                                                                                                                  (("2"
                                                                                                                                                    (inst
                                                                                                                                                     -
                                                                                                                                                     "abs(cc)"
                                                                                                                                                     "abs(cc)")
                                                                                                                                                    (("2"
                                                                                                                                                      (grind)
                                                                                                                                                      nil
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil)
                                                                                                                                       ("2"
                                                                                                                                        (replace
                                                                                                                                         "ffdef"
                                                                                                                                         +)
                                                                                                                                        (("2"
                                                                                                                                          (rewrite
                                                                                                                                           "div_expt")
                                                                                                                                          (("2"
                                                                                                                                            (cross-mult
                                                                                                                                             1)
                                                                                                                                            (("2"
                                                                                                                                              (mult-by
                                                                                                                                               -1
                                                                                                                                               "dd^2")
                                                                                                                                              (("1"
                                                                                                                                                (assert)
                                                                                                                                                nil
                                                                                                                                                nil)
                                                                                                                                               ("2"
                                                                                                                                                (hide-all-but
                                                                                                                                                 1)
                                                                                                                                                (("2"
                                                                                                                                                  (lemma
                                                                                                                                                   "nnreal_times_nnreal_is_nnreal")
                                                                                                                                                  (("2"
                                                                                                                                                    (inst
                                                                                                                                                     -
                                                                                                                                                     "abs(dd)"
                                                                                                                                                     "abs(dd)")
                                                                                                                                                    (("2"
                                                                                                                                                      (grind)
                                                                                                                                                      nil
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil)
                                                                                                                                       ("3"
                                                                                                                                        (copy
                                                                                                                                         "ccabs")
                                                                                                                                        (("3"
                                                                                                                                          (copy
                                                                                                                                           -1)
                                                                                                                                          (("3"
                                                                                                                                            (mult-ineq
                                                                                                                                             -1
                                                                                                                                             -1)
                                                                                                                                            (("1"
                                                                                                                                              (expand
                                                                                                                                               "^"
                                                                                                                                               1)
                                                                                                                                              (("1"
                                                                                                                                                (expand
                                                                                                                                                 "expt"
                                                                                                                                                 1)
                                                                                                                                                (("1"
                                                                                                                                                  (expand
                                                                                                                                                   "expt"
                                                                                                                                                   1)
                                                                                                                                                  (("1"
                                                                                                                                                    (expand
                                                                                                                                                     "expt"
                                                                                                                                                     1)
                                                                                                                                                    (("1"
                                                                                                                                                      (hide-all-but
                                                                                                                                                       (-1
                                                                                                                                                        1))
                                                                                                                                                      (("1"
                                                                                                                                                        (grind)
                                                                                                                                                        nil
                                                                                                                                                        nil))
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil)
                                                                                                                                             ("2"
                                                                                                                                              (assert)
                                                                                                                                              nil
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil)
                                                                                                                                       ("4"
                                                                                                                                        (copy
                                                                                                                                         "ddabs")
                                                                                                                                        (("4"
                                                                                                                                          (copy
                                                                                                                                           -1)
                                                                                                                                          (("4"
                                                                                                                                            (mult-ineq
                                                                                                                                             -1
                                                                                                                                             -1)
                                                                                                                                            (("1"
                                                                                                                                              (hide-all-but
                                                                                                                                               (-1
                                                                                                                                                1))
                                                                                                                                              (("1"
                                                                                                                                                (grind)
                                                                                                                                                nil
                                                                                                                                                nil))
                                                                                                                                              nil)
                                                                                                                                             ("2"
                                                                                                                                              (assert)
                                                                                                                                              nil
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil)
                                                                                                                                     ("2"
                                                                                                                                      (case
                                                                                                                                       "gcd(cc,dd) >= 1")
                                                                                                                                      (("1"
                                                                                                                                        (copy
                                                                                                                                         -1)
                                                                                                                                        (("1"
                                                                                                                                          (mult-ineq
                                                                                                                                           -1
                                                                                                                                           -1)
                                                                                                                                          (("1"
                                                                                                                                            (expand
                                                                                                                                             "^"
                                                                                                                                             1)
                                                                                                                                            (("1"
                                                                                                                                              (expand
                                                                                                                                               "expt"
                                                                                                                                               1)
                                                                                                                                              (("1"
                                                                                                                                                (expand
                                                                                                                                                 "expt"
                                                                                                                                                 1)
                                                                                                                                                (("1"
                                                                                                                                                  (expand
                                                                                                                                                   "expt"
                                                                                                                                                   1)
                                                                                                                                                  (("1"
                                                                                                                                                    (assert)
                                                                                                                                                    nil
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil)
                                                                                                                                       ("2"
                                                                                                                                        (assert)
                                                                                                                                        nil
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil)
                                                                                                                         ("2"
                                                                                                                          (reveal
                                                                                                                           "xxpos")
                                                                                                                          (("2"
                                                                                                                            (lemma
                                                                                                                             "posreal_times_posreal_is_posreal")
                                                                                                                            (("2"
                                                                                                                              (inst
                                                                                                                               -
                                                                                                                               "-zz"
                                                                                                                               "xx")
                                                                                                                              (("1"
                                                                                                                                (assert)
                                                                                                                                nil
                                                                                                                                nil)
                                                                                                                               ("2"
                                                                                                                                (assert)
                                                                                                                                nil
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil)
                                                                                                                 ("2"
                                                                                                                  (copy
                                                                                                                   "xxccdddiv")
                                                                                                                  (("2"
                                                                                                                    (copy
                                                                                                                     "eedef")
                                                                                                                    (("2"
                                                                                                                      (cross-mult
                                                                                                                       -1)
                                                                                                                      (("2"
                                                                                                                        (replace
                                                                                                                         -1
                                                                                                                         -2
                                                                                                                         :dir
                                                                                                                         rl)
                                                                                                                        (("2"
                                                                                                                          (hide
                                                                                                                           -1)
                                                                                                                          (("2"
                                                                                                                            (copy
                                                                                                                             "ffdef")
                                                                                                                            (("2"
                                                                                                                              (cross-mult
                                                                                                                               -1)
                                                                                                                              (("2"
                                                                                                                                (case
                                                                                                                                 "dd^2 = (ff*gcd(cc,dd))^2")
                                                                                                                                (("1"
                                                                                                                                  (replace
                                                                                                                                   -1
                                                                                                                                   -3)
                                                                                                                                  (("1"
                                                                                                                                    (hide
                                                                                                                                     (-1
                                                                                                                                      -2))
                                                                                                                                    (("1"
                                                                                                                                      (lemma
                                                                                                                                       "rel_prime_div_prod")
                                                                                                                                      (("1"
                                                                                                                                        (inst
                                                                                                                                         -
                                                                                                                                         "xx"
                                                                                                                                         "gcd(cc,dd)"
                                                                                                                                         "gcd(cc,dd)*(ee^2 + ff^2)")
                                                                                                                                        (("1"
                                                                                                                                          (assert)
                                                                                                                                          (("1"
                                                                                                                                            (split
                                                                                                                                             -)
                                                                                                                                            (("1"
                                                                                                                                              (lemma
                                                                                                                                               "rel_prime_div_prod")
                                                                                                                                              (("1"
                                                                                                                                                (inst
                                                                                                                                                 -
                                                                                                                                                 "xx"
                                                                                                                                                 "gcd(cc,dd)"
                                                                                                                                                 "ee^2 + ff^2")
                                                                                                                                                (("1"
                                                                                                                                                  (assert)
                                                                                                                                                  (("1"
                                                                                                                                                    (rewrite
                                                                                                                                                     "rel_prime_sym"
                                                                                                                                                     +)
                                                                                                                                                    nil
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil)
                                                                                                                                             ("2"
                                                                                                                                              (rewrite
                                                                                                                                               "rel_prime_sym"
                                                                                                                                               +)
                                                                                                                                              nil
                                                                                                                                              nil)
                                                                                                                                             ("3"
                                                                                                                                              (hide-all-but
                                                                                                                                               (-1
                                                                                                                                                1))
                                                                                                                                              (("3"
                                                                                                                                                (expand
                                                                                                                                                 "divides")
                                                                                                                                                (("3"
                                                                                                                                                  (inst
                                                                                                                                                   +
                                                                                                                                                   "yy")
                                                                                                                                                  (("3"
                                                                                                                                                    (grind
                                                                                                                                                     :exclude
                                                                                                                                                     "gcd")
                                                                                                                                                    nil
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil)
                                                                                                                                 ("2"
                                                                                                                                  (assert)
                                                                                                                                  nil
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil)
                                                                                                           ("2"
                                                                                                            (hide-all-but
                                                                                                             (1
                                                                                                              2))
                                                                                                            (("2"
                                                                                                              (lemma
                                                                                                               "nnreal_times_nnreal_is_nnreal")
                                                                                                              (("2"
                                                                                                                (inst-cp
                                                                                                                 -
                                                                                                                 "abs(ee)"
                                                                                                                 "abs(ee)")
                                                                                                                (("2"
                                                                                                                  (inst
                                                                                                                   -
                                                                                                                   "abs(ff)"
                                                                                                                   "abs(ff)")
                                                                                                                  (("2"
                                                                                                                    (case
                                                                                                                     "ee^2 = 0 IMPLIES ee = 0")
                                                                                                                    (("1"
                                                                                                                      (case
                                                                                                                       "ff^2 = 0 IMPLIES ff = 0")
                                                                                                                      (("1"
                                                                                                                        (grind)
                                                                                                                        nil
                                                                                                                        nil)
                                                                                                                       ("2"
                                                                                                                        (lemma
                                                                                                                         "nzreal_times_nzreal_is_nzreal")
                                                                                                                        (("2"
                                                                                                                          (hide-all-but
                                                                                                                           (-1
                                                                                                                            1))
                                                                                                                          (("2"
                                                                                                                            (flatten)
                                                                                                                            (("2"
                                                                                                                              (expand
                                                                                                                               "^")
                                                                                                                              (("2"
                                                                                                                                (expand
                                                                                                                                 "expt")
                                                                                                                                (("2"
                                                                                                                                  (expand
                                                                                                                                   "expt")
                                                                                                                                  (("2"
                                                                                                                                    (expand
                                                                                                                                     "expt")
                                                                                                                                    (("2"
                                                                                                                                      (inst?)
                                                                                                                                      (("1"
                                                                                                                                        (assert)
                                                                                                                                        nil
                                                                                                                                        nil)
                                                                                                                                       ("2"
                                                                                                                                        (assert)
                                                                                                                                        nil
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil)
                                                                                                                     ("2"
                                                                                                                      (hide-all-but
                                                                                                                       1)
                                                                                                                      (("2"
                                                                                                                        (lemma
                                                                                                                         "nzreal_times_nzreal_is_nzreal")
                                                                                                                        (("2"
                                                                                                                          (flatten)
                                                                                                                          (("2"
                                                                                                                            (expand
                                                                                                                             "^")
                                                                                                                            (("2"
                                                                                                                              (expand
                                                                                                                               "expt")
                                                                                                                              (("2"
                                                                                                                                (expand
                                                                                                                                 "expt")
                                                                                                                                (("2"
                                                                                                                                  (expand
                                                                                                                                   "expt")
                                                                                                                                  (("2"
                                                                                                                                    (inst?)
                                                                                                                                    (("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)
                                                                                               ("2"
                                                                                                (hide-all-but
                                                                                                 1)
                                                                                                (("2"
                                                                                                  (typepred
                                                                                                   "gcd(cc,dd)")
                                                                                                  (("2"
                                                                                                    (expand
                                                                                                     "divides")
                                                                                                    (("2"
                                                                                                      (skosimp*)
                                                                                                      (("2"
                                                                                                        (inst
                                                                                                         +
                                                                                                         "x!2"
                                                                                                         "x!3")
                                                                                                        (("2"
                                                                                                          (split
                                                                                                           +)
                                                                                                          (("1"
                                                                                                            (cross-mult
                                                                                                             1)
                                                                                                            (("1"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil)
                                                                                                           ("2"
                                                                                                            (cross-mult
                                                                                                             1)
                                                                                                            (("2"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (case
                                                                                         "rel_prime(gcd(cc,dd)^2,xx)")
                                                                                        (("1"
                                                                                          (lemma
                                                                                           "rel_prime_div_prod")
                                                                                          (("1"
                                                                                            (inst
                                                                                             -
                                                                                             "gcd(cc,dd)^2"
                                                                                             "xx"
                                                                                             "yy")
                                                                                            (("1"
                                                                                              (assert)
                                                                                              (("1"
                                                                                                (replace
                                                                                                 "xxccdddiv"
                                                                                                 +
                                                                                                 :dir
                                                                                                 rl)
                                                                                                (("1"
                                                                                                  (hide-all-but
                                                                                                   1)
                                                                                                  (("1"
                                                                                                    (typepred
                                                                                                     "gcd(cc,dd)")
                                                                                                    (("1"
                                                                                                      (expand
                                                                                                       "divides")
                                                                                                      (("1"
                                                                                                        (skosimp*)
                                                                                                        (("1"
                                                                                                          (mult-eq
                                                                                                           -2
                                                                                                           -2)
                                                                                                          (("1"
                                                                                                            (mult-eq
                                                                                                             -4
                                                                                                             -4)
                                                                                                            (("1"
                                                                                                              (expand
                                                                                                               "^")
                                                                                                              (("1"
                                                                                                                (expand
                                                                                                                 "expt")
                                                                                                                (("1"
                                                                                                                  (expand
                                                                                                                   "expt")
                                                                                                                  (("1"
                                                                                                                    (expand
                                                                                                                     "expt")
                                                                                                                    (("1"
                                                                                                                      (replace
                                                                                                                       -1)
                                                                                                                      (("1"
                                                                                                                        (replace
                                                                                                                         -2)
                                                                                                                        (("1"
                                                                                                                          (inst
                                                                                                                           +
                                                                                                                           "x!1^2 + x!2^2")
                                                                                                                          (("1"
                                                                                                                            (hide
                                                                                                                             -)
                                                                                                                            (("1"
                                                                                                                              (grind
                                                                                                                               :exclude
                                                                                                                               "gcd")
                                                                                                                              nil
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (expand
                                                                                           "^"
                                                                                           1)
                                                                                          (("2"
                                                                                            (expand
                                                                                             "expt"
                                                                                             1)
                                                                                            (("2"
                                                                                              (expand
                                                                                               "expt"
                                                                                               1)
                                                                                              (("2"
                                                                                                (expand
                                                                                                 "expt"
                                                                                                 1)
                                                                                                (("2"
                                                                                                  (rewrite
                                                                                                   "rel_prime_mult_left")
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil)
                                                                                         ("3"
                                                                                          (assert)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (hide-all-but
                                                                               ("AAdef"
                                                                                "divxx"
                                                                                1))
                                                                              (("2"
                                                                                (expand
                                                                                 "divides")
                                                                                (("2"
                                                                                  (skosimp*)
                                                                                  (("2"
                                                                                    (replace
                                                                                     "divxx")
                                                                                    (("2"
                                                                                      (inst
                                                                                       +
                                                                                       "x!1-AA")
                                                                                      (("2"
                                                                                        (grind
                                                                                         :exclude
                                                                                         "^")
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("3"
                                                                            (assert)
                                                                            (("3"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil)
                                                                           ("4"
                                                                            (assert)
                                                                            (("4"
                                                                              (flatten)
                                                                              (("4"
                                                                                (assert)
                                                                                (("4"
                                                                                  (reveal
                                                                                   "ccddnz")
                                                                                  (("4"
                                                                                    (ground)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (replace
                                                                       "ccdef"
                                                                       +)
                                                                      (("2"
                                                                        (replace
                                                                         "dddef"
                                                                         +)
                                                                        (("2"
                                                                          (expand
                                                                           "^"
                                                                           1)
                                                                          (("2"
                                                                            (expand
                                                                             "expt"
                                                                             +)
                                                                            (("2"
                                                                              (expand
                                                                               "expt"
                                                                               +)
                                                                              (("2"
                                                                                (expand
                                                                                 "expt"
                                                                                 +)
                                                                                (("2"
                                                                                  (assert)
                                                                                  (("2"
                                                                                    (inst
                                                                                     +
                                                                                     "mm*mm*xx + nn*nn*xx +2*cc*mm+2*dd*nn")
                                                                                    (("2"
                                                                                      (hide-all-but
                                                                                       1)
                                                                                      (("2"
                                                                                        (assert)
                                                                                        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"
                                                      (reveal "xxpos")
                                                      (("2"
                                                        (case
                                                         "FORALL (aa:int): EXISTS (nn,kk:int): abs(kk)<=xx/2 AND aa = nn*xx+kk")
                                                        (("1"
                                                          (inst-cp
                                                           -
                                                           "pa")
                                                          (("1"
                                                            (inst
                                                             -
                                                             "pb")
                                                            (("1"
                                                              (skosimp*)
                                                              (("1"
                                                                (inst
                                                                 +
                                                                 "kk!2"
                                                                 "kk!1"
                                                                 "nn!2"
                                                                 "nn!1")
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (hide 2)
                                                          (("2"
                                                            (skeep)
                                                            (("2"
                                                              (case
                                                               "EXISTS (nn:int): nn*xx <= aa AND (nn+1)*xx > aa")
                                                              (("1"
                                                                (skeep
                                                                 -1)
                                                                (("1"
                                                                  (copy
                                                                   1)
                                                                  (("1"
                                                                    (inst
                                                                     +
                                                                     "nn"
                                                                     "aa-nn*xx")
                                                                    (("1"
                                                                      (inst
                                                                       +
                                                                       "nn+1"
                                                                       "aa-(nn+1)*xx")
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (grind)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (hide
                                                                 2)
                                                                (("2"
                                                                  (case
                                                                   "FORALL (a:nat): EXISTS (nn: int): nn * xx <= a AND (nn + 1) * xx > a")
                                                                  (("1"
                                                                    (case
                                                                     "NOT aa < 0")
                                                                    (("1"
                                                                      (inst
                                                                       -
                                                                       "aa")
                                                                      (("1"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (inst
                                                                       -
                                                                       "-aa")
                                                                      (("1"
                                                                        (skosimp*)
                                                                        (("1"
                                                                          (case
                                                                           "nn!1*xx = -aa")
                                                                          (("1"
                                                                            (inst
                                                                             +
                                                                             "-nn!1")
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (inst
                                                                             +
                                                                             "-nn!1-1")
                                                                            (("2"
                                                                              (grind)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (hide
                                                                     2)
                                                                    (("2"
                                                                      (lemma
                                                                       "axiom_of_archimedes")
                                                                      (("2"
                                                                        (skeep)
                                                                        (("2"
                                                                          (case
                                                                           "FORALL (ii:nat): ii*xx <= a")
                                                                          (("1"
                                                                            (inst
                                                                             -2
                                                                             "a/xx")
                                                                            (("1"
                                                                              (case
                                                                               "EXISTS (i:nat): a/xx < i")
                                                                              (("1"
                                                                                (hide
                                                                                 -3)
                                                                                (("1"
                                                                                  (skosimp*)
                                                                                  (("1"
                                                                                    (cross-mult
                                                                                     -1)
                                                                                    (("1"
                                                                                      (inst
                                                                                       -
                                                                                       "i!1")
                                                                                      (("1"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (skosimp*)
                                                                                (("2"
                                                                                  (lemma
                                                                                   "nnreal_div_posreal_is_nnreal")
                                                                                  (("2"
                                                                                    (inst
                                                                                     -
                                                                                     "a"
                                                                                     "xx")
                                                                                    (("2"
                                                                                      (assert)
                                                                                      (("2"
                                                                                        (inst
                                                                                         +
                                                                                         "i!1")
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("3"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (induct
                                                                             "ii")
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil)
                                                                             ("2"
                                                                              (skosimp*)
                                                                              (("2"
                                                                                (inst
                                                                                 +
                                                                                 "j!1")
                                                                                (("2"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (assertnil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("3" (hide 2) (("3" (skosimp*) (("3" (ground) nil nil)) nil))
          nil))
        nil))
      nil)
     ("3" (hide 2) (("3" (skosimp*) (("3" (ground) nil nil)) nil))
      nil))
    nil)
   ((nnrat_div_posrat_is_nnrat application-judgement "nonneg_rat"
     rationals nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (abs_0_rew formula-decl nil abs_rews "ints/")
    (int_abs_is_nonneg application-judgement "{j: nonneg_int | j >= i}"
     real_defs nil)
    (gcd const-decl "{k: posnat | divides(k, i) AND divides(k, j)}" gcd
         "ints/")
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (< const-decl "bool" reals nil)
    (x!1 skolem-const-decl "int" primes_sum_squares nil)
    (rat_div_nzrat_is_rat application-judgement "rat" rationals nil)
    (div_cancel4 formula-decl nil real_props nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (rel_prime_div_prod formula-decl nil gcd "ints/")
    (rel_prime_sym formula-decl nil gcd "ints/")
    (zz skolem-const-decl "int" primes_sum_squares nil)
    (ee skolem-const-decl "int" primes_sum_squares nil)
    (ff skolem-const-decl "int" primes_sum_squares nil)
    (abs_nat_rew formula-decl nil abs_rews "ints/")
    (both_sides_times_pos_le1 formula-decl nil real_props nil)
    (x!2 skolem-const-decl "int" primes_sum_squares nil)
    (b skolem-const-decl "nat" primes_sum_squares nil)
    (div_cancel3 formula-decl nil real_props nil)
    (int_expt application-judgement "int" exponentiation nil)
    (sots_div_quot_factor formula-decl nil primes_sum_squares nil)
    (gcd_factors formula-decl nil gcd "ints/")
    (both_sides_times1 formula-decl nil real_props nil)
    (rel_prime_lem formula-decl nil gcd "ints/")
    (odd_times_odd_is_odd application-judgement "odd_int" integers nil)
    (ge_times_ge_any1 formula-decl nil extra_real_props nil)
    (nzreal nonempty-type-eq-decl nil reals nil)
    (div_expt formula-decl nil exponentiation nil)
    (rat_exp application-judgement "rat" exponentiation nil)
    (both_sides_times_pos_ge1_imp formula-decl nil extra_real_props
     nil)
    (cc skolem-const-decl "int" primes_sum_squares nil)
    (nnreal_times_nnreal_is_nnreal judgement-tcc nil real_types nil)
    (div_mult_pos_le1 formula-decl nil real_props nil)
    (dd skolem-const-decl "int" primes_sum_squares nil)
    (rat_abs_is_nonneg application-judgement "{r: nonneg_rat | r >= q}"
     real_defs nil)
    (le_times_le_any1 formula-decl nil extra_real_props nil)
    (nnrat_times_nnrat_is_nnrat application-judgement "nonneg_rat"
     rationals nil)
    (nzreal_times_nzreal_is_nzreal judgement-tcc nil real_types nil)
    (rel_prime_mult_left formula-decl nil gcd "ints/")
    (aa skolem-const-decl "int" primes_sum_squares nil)
    (axiom_of_archimedes formula-decl nil real_props nil)
    (div_mult_pos_lt1 formula-decl nil real_props nil)
    (nnreal_div_posreal_is_nnreal judgement-tcc nil real_types nil)
    (xx skolem-const-decl "nat" primes_sum_squares nil)
    (nzint nonempty-type-eq-decl nil integers nil)
    (posnat_expt application-judgement "posnat" exponentiation nil)
    (posrat_div_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (both_sides_times_pos_gt1 formula-decl nil real_props nil)
    (posreal_times_posreal_is_posreal judgement-tcc nil real_types nil)
    (x!1 skolem-const-decl "int" primes_sum_squares nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (minus_int_is_int application-judgement "int" integers nil)
    (divides_gcd formula-decl nil gcd "ints/")
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (int_exp application-judgement "int" exponentiation nil)
    (nat_exp application-judgement "nat" exponentiation nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (nat_expt application-judgement "nat" exponentiation nil)
    (nzrat_div_nzrat_is_nzrat application-judgement "nzrat" rationals
     nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (expt def-decl "real" exponentiation nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (posint_exp application-judgement "posint" exponentiation nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans 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)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (/= const-decl "boolean" notequal nil)
    (rel_prime const-decl "bool" gcd "ints/")
    (divides const-decl "bool" divides nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (^ const-decl "real" exponentiation nil)
    (sum_of_two_squares? const-decl "bool" primes_sum_squares nil))
   nil)
  (new "" 3539694599
   (""
    (case "FORALL (m:nat, n: nat, pa, pb: posnat): n<=m AND
                      rel_prime(pa, pb) AND divides(n, pa ^ 2 + pb ^ 2) IMPLIES
                       sum_of_two_squares?(n)")
    (("1" (skeep)
      (("1" (inst - "n" "n" "pa" "pb") (("1" (assertnil nil)) nil))
      nil)
     ("2" (hide 2)
      (("2" (induct "m")
        (("1" (skeep)
          (("1" (case "n = 0")
            (("1" (replace -1)
              (("1" (hide -)
                (("1" (expand "sum_of_two_squares?")
                  (("1" (inst + "0" "0") (("1" (grind) nil nil)) nil))
                  nil))
                nil))
              nil)
             ("2" (assertnil nil))
            nil))
          nil)
         ("2" (skeep)
          (("2" (skeep)
            (("2" (case "NOT j = n-1")
              (("1" (inst - "n" "pa" "pb") (("1" (assertnil nil))
                nil)
               ("2" (replace -1)
                (("2" (hide -3)
                  (("2" (name "xx" "n")
                    (("2" (replace -1)
                      (("2" (label "hyp" -3)
                        (("2" (hide (-1 -2))
                          (("2" (hide "hyp")
                            (("2"
                              (case "divides(xx,pa) AND divides(xx,pb)")
                              (("1"
                                (flatten)
                                (("1"
                                  (lemma "divides_gcd")
                                  (("1"
                                    (inst - "pa" "pb" "xx")
                                    (("1"
                                      (assert)
                                      (("1"
                                        (expand "rel_prime")
                                        (("1"
                                          (replace -4)
                                          (("1"
                                            (case "xx = 1")
                                            (("1"
                                              (replace -1)
                                              (("1"
                                                (hide -)
                                                (("1"
                                                  (expand
                                                   "sum_of_two_squares?")
                                                  (("1"
                                                    (inst + "0" "1")
                                                    (("1"
                                                      (grind)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (hide-all-but (-1 1))
                                              (("2"
                                                (expand "divides")
                                                (("2"
                                                  (skosimp*)
                                                  (("2"
                                                    (case "x!1 > 1")
                                                    (("1"
                                                      (mult-by -1 "xx")
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (case "x!1 = 1")
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil)
                                                       ("2"
                                                        (lemma
                                                         "posreal_times_posreal_is_posreal")
                                                        (("2"
                                                          (inst
                                                           -
                                                           "-x!1"
                                                           "xx")
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil)
                                                           ("2"
                                                            (assert)
                                                            nil
                                                            nil)
                                                           ("3"
                                                            (ground)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (assert)
                                      (("2"
                                        (flatten)
                                        (("2"
                                          (replace -1)
                                          (("2"
                                            (hide -)
                                            (("2"
                                              (expand
                                               "sum_of_two_squares?")
                                              (("2"
                                                (inst + "0" "0")
                                                (("2" (grind) nil nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (label "xxdivpapb" 1)
                                (("2"
                                  (hide "xxdivpapb")
                                  (("2"
                                    (label "divxx" -2)
                                    (("2"
                                      (label "papbrp" -1)
                                      (("2"
                                        (case
                                         "EXISTS (cc,dd,mm,nn:nat): abs(cc)<=xx/2 AND abs(dd)<=xx/2 AND pa = mm*xx+cc AND pb = nn*xx+dd")
                                        (("1"
                                          (skeep -1)
                                          (("1"
                                            (case
                                             "(cc = 0 AND dd = 0)")
                                            (("1"
                                              (flatten)
                                              (("1"
                                                (replace -1)
                                                (("1"
                                                  (replace -2)
                                                  (("1"
                                                    (reveal
                                                     "xxdivpapb")
                                                    (("1"
                                                      (expand
                                                       "divides"
                                                       +)
                                                      (("1"
                                                        (split +)
                                                        (("1"
                                                          (inst + "mm")
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (inst + "nn")
                                                          (("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (label "ccddnz" 1)
                                              (("2"
                                                (hide "ccddnz")
                                                (("2"
                                                  (case
                                                   "EXISTS (AA:int): pa^2 + pb^2 = AA*xx + (cc^2 + dd^2)")
                                                  (("1"
                                                    (skeep -1)
                                                    (("1"
                                                      (case
                                                       "NOT rel_prime(gcd(cc,dd),xx)")
                                                      (("1"
                                                        (expand
                                                         "rel_prime"
                                                         +)
                                                        (("1"
                                                          (case
                                                           "divides(gcd(cc,dd),pa) AND divides(gcd(cc,dd),pb)")
                                                          (("1"
                                                            (flatten)
                                                            (("1"
                                                              (lemma
                                                               "divides_gcd")
                                                              (("1"
                                                                (inst
                                                                 -
                                                                 "pa"
                                                                 "pb"
                                                                 "gcd(cc,dd)")
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (expand
                                                                     "rel_prime")
                                                                    (("1"
                                                                      (replace
                                                                       "papbrp")
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (expand
                                                                           "divides"
                                                                           -1)
                                                                          (("1"
                                                                            (skosimp*)
                                                                            (("1"
                                                                              (case
                                                                               "x!1 > 1")
                                                                              (("1"
                                                                                (mult-by
                                                                                 -1
                                                                                 "gcd(cc,dd)")
                                                                                (("1"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (case
                                                                                 "x!1 = 1")
                                                                                (("1"
                                                                                  (replace
                                                                                   -1)
                                                                                  (("1"
                                                                                    (assert)
                                                                                    (("1"
                                                                                      (replace
                                                                                       -2
                                                                                       :dir
                                                                                       rl)
                                                                                      (("1"
                                                                                        (assert)
                                                                                        (("1"
                                                                                          (hide-all-but
                                                                                           2)
                                                                                          (("1"
                                                                                            (typepred
                                                                                             "gcd(1,xx)")
                                                                                            (("1"
                                                                                              (hide
                                                                                               (-1
                                                                                                -3))
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "divides")
                                                                                                (("1"
                                                                                                  (skosimp*)
                                                                                                  (("1"
                                                                                                    (case
                                                                                                     "x!2 > 1")
                                                                                                    (("1"
                                                                                                      (mult-by
                                                                                                       -1
                                                                                                       "gcd(1,xx)")
                                                                                                      (("1"
                                                                                                        (assert)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (case
                                                                                                       "x!2 = 1")
                                                                                                      (("1"
                                                                                                        (assert)
                                                                                                        nil
                                                                                                        nil)
                                                                                                       ("2"
                                                                                                        (assert)
                                                                                                        (("2"
                                                                                                          (case
                                                                                                           "x!2 < 0")
                                                                                                          (("1"
                                                                                                            (lemma
                                                                                                             "posreal_times_posreal_is_posreal")
                                                                                                            (("1"
                                                                                                              (inst
                                                                                                               -
                                                                                                               "-x!2"
                                                                                                               "gcd(1,xx)")
                                                                                                              (("1"
                                                                                                                (assert)
                                                                                                                nil
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil)
                                                                                                           ("2"
                                                                                                            (assert)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (assert)
                                                                                  (("2"
                                                                                    (lemma
                                                                                     "posreal_times_posreal_is_posreal")
                                                                                    (("2"
                                                                                      (inst
                                                                                       -
                                                                                       "-x!1"
                                                                                       "gcd(cc,dd)")
                                                                                      (("2"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (case
                                                             "FORALL (ab1,mn1,cd1,dg1:nat): divides(dg1,cd1) AND divides(dg1,xx) AND ab1 = mn1*xx + cd1 IMPLIES divides(dg1,ab1)")
                                                            (("1"
                                                              (inst-cp
                                                               -
                                                               "pa"
                                                               "mm"
                                                               "cc"
                                                               "gcd(gcd(cc,dd),xx)")
                                                              (("1"
                                                                (inst
                                                                 -
                                                                 "pb"
                                                                 "nn"
                                                                 "dd"
                                                                 "gcd(gcd(cc,dd),xx)")
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (case
                                                                     "FORALL (rrz,xxz,ccz:int): divides(rrz,xxz) AND divides(xxz,ccz) IMPLIES divides(rrz,ccz)")
                                                                    (("1"
                                                                      (split
                                                                       -)
                                                                      (("1"
                                                                        (split
                                                                         -)
                                                                        (("1"
                                                                          (hide
                                                                           -3)
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (copy
                                                                               "papbrp")
                                                                              (("1"
                                                                                (expand
                                                                                 "rel_prime"
                                                                                 -1)
                                                                                (("1"
                                                                                  (lemma
                                                                                   "divides_gcd")
                                                                                  (("1"
                                                                                    (inst
                                                                                     -
                                                                                     "pa"
                                                                                     "pb"
                                                                                     "gcd(gcd(cc,dd),xx)")
                                                                                    (("1"
                                                                                      (assert)
                                                                                      (("1"
                                                                                        (replace
                                                                                         -2)
                                                                                        (("1"
                                                                                          (hide-all-but
                                                                                           (-1
                                                                                            2))
                                                                                          (("1"
                                                                                            (expand
                                                                                             "divides")
                                                                                            (("1"
                                                                                              (skosimp*)
                                                                                              (("1"
                                                                                                (case
                                                                                                 "x!1 > 1")
                                                                                                (("1"
                                                                                                  (mult-by
                                                                                                   -1
                                                                                                   "gcd(gcd(cc,dd),xx)")
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    nil
                                                                                                    nil))
                                                                                                  nil)
                                                                                                 ("2"
                                                                                                  (case
                                                                                                   "x!1 = 1")
                                                                                                  (("1"
                                                                                                    (replace
                                                                                                     -1)
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil)
                                                                                                   ("2"
                                                                                                    (lemma
                                                                                                     "posreal_times_posreal_is_posreal")
                                                                                                    (("2"
                                                                                                      (inst
                                                                                                       -
                                                                                                       "-x!1"
                                                                                                       "gcd(gcd(cc,dd),xx)")
                                                                                                      (("1"
                                                                                                        (assert)
                                                                                                        nil
                                                                                                        nil)
                                                                                                       ("2"
                                                                                                        (ground)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (hide-all-but
                                                                           (-2
                                                                            1))
                                                                          (("2"
                                                                            (inst
                                                                             -
                                                                             "gcd(gcd(cc,dd),xx)"
                                                                             "gcd(cc,dd)"
                                                                             "cc")
                                                                            (("2"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (hide-all-but
                                                                         (-1
                                                                          1))
                                                                        (("2"
                                                                          (inst
                                                                           -
                                                                           "gcd(gcd(cc,dd),xx)"
                                                                           "gcd(cc,dd)"
                                                                           "dd")
                                                                          (("2"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (hide-all-but
                                                                       1)
                                                                      (("2"
                                                                        (skosimp*)
                                                                        (("2"
                                                                          (expand
                                                                           "divides")
                                                                          (("2"
                                                                            (skosimp*)
                                                                            (("2"
                                                                              (replace
                                                                               -1)
                                                                              (("2"
                                                                                (inst
                                                                                 +
                                                                                 "x!1*x!2")
                                                                                (("2"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (hide-all-but
                                                               1)
                                                              (("2"
                                                                (skeep)
                                                                (("2"
                                                                  (expand
                                                                   "divides")
                                                                  (("2"
                                                                    (skosimp*)
                                                                    (("2"
                                                                      (replace
                                                                       -1)
                                                                      (("2"
                                                                        (replace
                                                                         -2)
                                                                        (("2"
                                                                          (inst
                                                                           +
                                                                           "mn1*x!2 + x!1")
                                                                          (("2"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (case
                                                         "divides(xx,cc^2 + dd^2)")
                                                        (("1"
                                                          (expand
                                                           "divides"
                                                           -1)
                                                          (("1"
                                                            (skolem
                                                             -1
                                                             "yy")
                                                            (("1"
                                                              (case
                                                               "divides(gcd(cc,dd)^2,yy)")
                                                              (("1"
                                                                (expand
                                                                 "divides"
                                                                 -1)
                                                                (("1"
                                                                  (skosimp*)
                                                                  (("1"
                                                                    (case
                                                                     "EXISTS (ee,ff:nat): ee = cc/gcd(cc,dd) AND ff = dd/gcd(cc,dd)")
                                                                    (("1"
                                                                      (skeep
                                                                       -1)
                                                                      (("1"
                                                                        (case
                                                                         "(ee = 0 AND ff = 0)")
                                                                        (("1"
                                                                          (reveal
                                                                           "ccddnz")
                                                                          (("1"
                                                                            (hide-all-but
                                                                             (-1
                                                                              -2
                                                                              -3
                                                                              1))
                                                                            (("1"
                                                                              (flatten)
                                                                              (("1"
                                                                                (replace
                                                                                 -1)
                                                                                (("1"
                                                                                  (replace
                                                                                   -2)
                                                                                  (("1"
                                                                                    (cross-mult
                                                                                     -3)
                                                                                    (("1"
                                                                                      (cross-mult
                                                                                       -4)
                                                                                      (("1"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (label
                                                                           "eeffnz"
                                                                           1)
                                                                          (("2"
                                                                            (hide
                                                                             "eeffnz")
                                                                            (("2"
                                                                              (case
                                                                               "ee <= cc AND ff <= dd")
                                                                              (("1"
                                                                                (flatten)
                                                                                (("1"
                                                                                  (case
                                                                                   "divides(xx,ee^2 + ff^2)")
                                                                                  (("1"
                                                                                    (copy
                                                                                     -1)
                                                                                    (("1"
                                                                                      (expand
                                                                                       "divides"
                                                                                       -1)
                                                                                      (("1"
                                                                                        (skolem
                                                                                         -1
                                                                                         "zz")
                                                                                        (("1"
                                                                                          (case
                                                                                           "abs(zz) <= xx/2")
                                                                                          (("1"
                                                                                            (case
                                                                                             "rel_prime(ee,ff)")
                                                                                            (("1"
                                                                                              (lemma
                                                                                               "sots_div_quot_factor")
                                                                                              (("1"
                                                                                                (inst
                                                                                                 -
                                                                                                 "xx"
                                                                                                 "ee^2 + ff^2")
                                                                                                (("1"
                                                                                                  (assert)
                                                                                                  (("1"
                                                                                                    (split
                                                                                                     -)
                                                                                                    (("1"
                                                                                                      (skeep
                                                                                                       -1)
                                                                                                      (("1"
                                                                                                        (reveal
                                                                                                         "hyp")
                                                                                                        (("1"
                                                                                                          (inst
                                                                                                           -
                                                                                                           "b"
                                                                                                           "ee"
                                                                                                           "ff")
                                                                                                          (("1"
                                                                                                            (assert)
                                                                                                            (("1"
                                                                                                              (case
                                                                                                               "zz>=0")
                                                                                                              (("1"
                                                                                                                (expand
                                                                                                                 "abs")
                                                                                                                (("1"
                                                                                                                  (assert)
                                                                                                                  (("1"
                                                                                                                    (case
                                                                                                                     "b <=zz")
                                                                                                                    (("1"
                                                                                                                      (assert)
                                                                                                                      (("1"
                                                                                                                        (hide-all-but
                                                                                                                         (-3
                                                                                                                          1))
                                                                                                                        (("1"
                                                                                                                          (expand
                                                                                                                           "divides")
                                                                                                                          (("1"
                                                                                                                            (skosimp*)
                                                                                                                            (("1"
                                                                                                                              (cross-mult
                                                                                                                               -1)
                                                                                                                              (("1"
                                                                                                                                (inst
                                                                                                                                 +
                                                                                                                                 "x!2*xx")
                                                                                                                                (("1"
                                                                                                                                  (assert)
                                                                                                                                  nil
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil)
                                                                                                                     ("2"
                                                                                                                      (assert)
                                                                                                                      (("2"
                                                                                                                        (replace
                                                                                                                         -5)
                                                                                                                        (("2"
                                                                                                                          (assert)
                                                                                                                          (("2"
                                                                                                                            (case
                                                                                                                             "zz = 0")
                                                                                                                            (("1"
                                                                                                                              (replace
                                                                                                                               -1)
                                                                                                                              (("1"
                                                                                                                                (hide-all-but
                                                                                                                                 -6)
                                                                                                                                (("1"
                                                                                                                                  (reveal
                                                                                                                                   "eeffnz")
                                                                                                                                  (("1"
                                                                                                                                    (case
                                                                                                                                     "FORALL (ee1:real): ee1^2 >= 0")
                                                                                                                                    (("1"
                                                                                                                                      (inst-cp
                                                                                                                                       -
                                                                                                                                       "ee")
                                                                                                                                      (("1"
                                                                                                                                        (inst
                                                                                                                                         -
                                                                                                                                         "ff")
                                                                                                                                        (("1"
                                                                                                                                          (case
                                                                                                                                           "FORALL (xr:real): xr^2 =0 IMPLIES xr = 0")
                                                                                                                                          (("1"
                                                                                                                                            (inst-cp
                                                                                                                                             -
                                                                                                                                             "ee")
                                                                                                                                            (("1"
                                                                                                                                              (inst
                                                                                                                                               -
                                                                                                                                               "ff")
                                                                                                                                              (("1"
                                                                                                                                                (assert)
                                                                                                                                                nil
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil)
                                                                                                                                           ("2"
                                                                                                                                            (hide-all-but
                                                                                                                                             1)
                                                                                                                                            (("2"
                                                                                                                                              (skeep)
                                                                                                                                              (("2"
                                                                                                                                                (lemma
                                                                                                                                                 "nzreal_times_nzreal_is_nzreal")
                                                                                                                                                (("2"
                                                                                                                                                  (inst
                                                                                                                                                   -
                                                                                                                                                   "xr"
                                                                                                                                                   "xr")
                                                                                                                                                  (("1"
                                                                                                                                                    (grind)
                                                                                                                                                    nil
                                                                                                                                                    nil)
                                                                                                                                                   ("2"
                                                                                                                                                    (assert)
                                                                                                                                                    nil
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil)
                                                                                                                                     ("2"
                                                                                                                                      (hide-all-but
                                                                                                                                       1)
                                                                                                                                      (("2"
                                                                                                                                        (grind)
                                                                                                                                        nil
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil)
                                                                                                                             ("2"
                                                                                                                              (label
                                                                                                                               "zzero"
                                                                                                                               1)
                                                                                                                              (("2"
                                                                                                                                (postpone)
                                                                                                                                nil
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil)
                                                                                                               ("2"
                                                                                                                (postpone)
                                                                                                                nil
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil)
                                                                                                           ("2"
                                                                                                            (postpone)
                                                                                                            nil
                                                                                                            nil)
                                                                                                           ("3"
                                                                                                            (postpone)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (postpone)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil)
                                                                                                 ("2"
                                                                                                  (postpone)
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil)
                                                                                             ("2"
                                                                                              (postpone)
                                                                                              nil
                                                                                              nil)
                                                                                             ("3"
                                                                                              (postpone)
                                                                                              nil
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (postpone)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil)
                                                                                   ("2"
                                                                                    (postpone)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (postpone)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (postpone)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (postpone)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (postpone)
                                                          nil
                                                          nil))
                                                        nil)
                                                       ("3"
                                                        (postpone)
                                                        nil
                                                        nil)
                                                       ("4"
                                                        (postpone)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (postpone)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2" (postpone) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   nil shostak)
  (rel_prime_sos_factor-1 nil 3502105281
   (""
    (case "FORALL (m: nat): FORALL (n:nat, pa, pb: posnat): n<=m AND
                      rel_prime(pa, pb) AND divides(n, pa ^ 2 + pb ^ 2) IMPLIES
                       sum_of_two_squares?(n)")
    (("1" (skeep)
      (("1" (inst - "n")
        (("1" (inst - "n" "pa" "pb") (("1" (assertnil nil)) nil))
        nil))
      nil)
     ("2" (hide 2)
      (("2" (induct "m")
        (("1" (skeep)
          (("1" (case "n = 0")
            (("1" (replace -1)
              (("1" (hide -)
                (("1" (expand "sum_of_two_squares?")
                  (("1" (inst + "0" "0") (("1" (grind) nil nil)) nil))
                  nil))
                nil))
              nil)
             ("2" (assertnil nil))
            nil))
          nil)
         ("2" (assert)
          (("2" (skeep)
            (("2" (assert)
              (("2" (label "oldlem" -1)
                (("2" (skeep)
                  (("2" (name "xx" "n")
                    (("2" (replace -1)
                      (("2" (hide -1)
                        (("2" (case "xx > 0")
                          (("1" (label "xxpos" -1)
                            (("1"
                              (case "NOT (FORALL (kk:posnat): kk >= 2 IMPLIES NOT divides(kk^2,xx))")
                              (("1"
                                (skeep)
                                (("1"
                                  (case "kk^2 >= 4")
                                  (("1"
                                    (case "kk^2 < xx")
                                    (("1"
                                      (label "divideskkx" -4)
                                      (("1"
                                        (label "kge2" -3)
                                        (("1"
                                          (label "kkge4" -2)
                                          (("1"
                                            (label "kkltx" -1)
                                            (("1"
                                              (case
                                               "EXISTS (nn:posnat): nn = xx/kk^2")
                                              (("1"
                                                (skeep -1)
                                                (("1"
                                                  (case "nn < xx")
                                                  (("1"
                                                    (label "nndef" -2)
                                                    (("1"
                                                      (label
                                                       "nnltx"
                                                       -1)
                                                      (("1"
                                                        (case
                                                         "divides(nn,pa^2 + pb^2)")
                                                        (("1"
                                                          (inst
                                                           -
                                                           "nn"
                                                           "pa"
                                                           "pb")
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (hide-all-but
                                                               (-3
                                                                -5
                                                                "oldlem"
                                                                +))
                                                              (("1"
                                                                (expand
                                                                 "sum_of_two_squares?")
                                                                (("1"
                                                                  (skosimp*)
                                                                  (("1"
                                                                    (replace
                                                                     -1)
                                                                    (("1"
                                                                      (copy
                                                                       "oldlem")
                                                                      (("1"
                                                                        (cross-mult
                                                                         -1)
                                                                        (("1"
                                                                          (inst
                                                                           +
                                                                           "a!1*kk"
                                                                           "b!1*kk")
                                                                          (("1"
                                                                            (replace
                                                                             -1
                                                                             +)
                                                                            (("1"
                                                                              (hide
                                                                               -)
                                                                              (("1"
                                                                                (expand
                                                                                 "^")
                                                                                (("1"
                                                                                  (expand
                                                                                   "expt")
                                                                                  (("1"
                                                                                    (expand
                                                                                     "expt")
                                                                                    (("1"
                                                                                      (expand
                                                                                       "expt")
                                                                                      (("1"
                                                                                        (propax)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (case
                                                           "FORALL (a1,b1,c1:nat): divides(a1,b1) AND divides(b1,c1) IMPLIES divides(a1,c1)")
                                                          (("1"
                                                            (inst
                                                             -
                                                             "nn"
                                                             "xx"
                                                             "pa^2 + pb^2")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (expand
                                                                 "divides"
                                                                 1)
                                                                (("1"
                                                                  (inst
                                                                   +
                                                                   "kk^2")
                                                                  (("1"
                                                                    (mult-by
                                                                     -2
                                                                     "kk^2")
                                                                    (("1"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (hide-all-but
                                                             1)
                                                            (("2"
                                                              (skeep)
                                                              (("2"
                                                                (expand
                                                                 "divides")
                                                                (("2"
                                                                  (skeep
                                                                   -1)
                                                                  (("2"
                                                                    (replace
                                                                     -1)
                                                                    (("2"
                                                                      (skeep
                                                                       -2)
                                                                      (("2"
                                                                        (inst
                                                                         +
                                                                         "x*x_1")
                                                                        (("2"
                                                                          (assert)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (replace -1)
                                                    (("2"
                                                      (cross-mult 1)
                                                      (("2"
                                                        (copy "kkge4")
                                                        (("2"
                                                          (mult-by
                                                           -1
                                                           "xx")
                                                          (("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (copy "divideskkx")
                                                (("2"
                                                  (expand "divides" -1)
                                                  (("2"
                                                    (skeep -1)
                                                    (("2"
                                                      (inst + "x")
                                                      (("1"
                                                        (cross-mult 1)
                                                        (("1"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (assert)
                                                        (("2"
                                                          (lemma
                                                           "posreal_times_posreal_is_posreal")
                                                          (("2"
                                                            (inst
                                                             -
                                                             "-x"
                                                             "kk^2")
                                                            (("1"
                                                              (assert)
                                                              nil
                                                              nil)
                                                             ("2"
                                                              (ground)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (case "kk^2 = xx")
                                      (("1"
                                        (replace -1 + :dir rl)
                                        (("1"
                                          (hide -)
                                          (("1"
                                            (expand
                                             "sum_of_two_squares?")
                                            (("1"
                                              (inst + "0" "kk")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (expand "^")
                                                  (("1"
                                                    (expand "expt")
                                                    (("1"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (expand "divides" -3)
                                        (("2"
                                          (skeep -3)
                                          (("2"
                                            (replace -3 +)
                                            (("2"
                                              (case "x > 1")
                                              (("1"
                                                (mult-by -1 "kk^2")
                                                (("1"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil)
                                               ("2"
                                                (assert)
                                                (("2"
                                                  (case "x = 1")
                                                  (("1"
                                                    (replace -1)
                                                    (("1"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (lemma
                                                     "posreal_times_posreal_is_posreal")
                                                    (("2"
                                                      (inst
                                                       -
                                                       "-x"
                                                       "kk^2")
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil)
                                                       ("2"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (hide-all-but (-1 1))
                                    (("2"
                                      (copy -1)
                                      (("2"
                                        (mult-by -2 "kk")
                                        (("2"
                                          (expand "^")
                                          (("2"
                                            (expand "expt")
                                            (("2"
                                              (expand "expt")
                                              (("2"
                                                (expand "expt")
                                                (("2"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (label "xdivsq" -1)
                                (("2"
                                  (label "xxlt" -4)
                                  (("2"
                                    (hide
                                     ("xdivsq"
                                      "xxpos"
                                      "oldlem"
                                      "xxlt"))
                                    (("2"
                                      (case
                                       "EXISTS (cc,dd,mm,nn:nat): abs(cc)<=xx/2 AND abs(dd)<=xx/2 AND pa = mm*xx+cc AND pb = nn*xx+dd")
                                      (("1"
                                        (skeep -1)
                                        (("1"
                                          (case
                                           "NOT divides(xx,cc^2+dd^2)")
                                          (("1"
                                            (label "ccdef" -1)
                                            (("1"
                                              (label "dddef" -2)
                                              (("1"
                                                (label "relprime" -5)
                                                (("1"
                                                  (label
                                                   "dividesab"
                                                   -6)
                                                  (("1"
                                                    (lemma
                                                     "divides_sum")
                                                    (("1"
                                                      (inst
                                                       -
                                                       "(mm * xx + cc) ^ 2 + (nn * xx + dd) ^ 2"
                                                       "-(mm * xx + cc) ^ 2 - (nn * xx + dd) ^ 2+cc^2+dd^2"
                                                       "xx")
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (hide-all-but
                                                           1)
                                                          (("1"
                                                            (grind
                                                             :exclude
                                                             "divides")
                                                            (("1"
                                                              (expand
                                                               "divides")
                                                              (("1"
                                                                (inst
                                                                 +
                                                                 "-(mm * mm * xx + cc * mm + (cc * mm)) -
                                                               nn * nn * xx
                                                               - 2 * (dd * nn)")
                                                                (("1"
                                                                  (grind)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (expand "divides" -1)
                                            (("2"
                                              (skolem -1 "yy")
                                              (("2"
                                                (case
                                                 "NOT rel_prime(cc,dd)")
                                                (("1"
                                                  (case
                                                   "divides(gcd(cc,dd),xx)")
                                                  (("1"
                                                    (expand
                                                     "rel_prime"
                                                     +)
                                                    (("1"
                                                      (case
                                                       "divides(gcd(cc,dd),pa) AND divides(gcd(cc,dd),pb)")
                                                      (("1"
                                                        (flatten)
                                                        (("1"
                                                          (lemma
                                                           "divides_gcd")
                                                          (("1"
                                                            (inst
                                                             -
                                                             "pa"
                                                             "pb"
                                                             "gcd(cc,dd)")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (expand
                                                                 "rel_prime")
                                                                (("1"
                                                                  (replace
                                                                   -10)
                                                                  (("1"
                                                                    (expand
                                                                     "divides"
                                                                     -1)
                                                                    (("1"
                                                                      (skosimp*)
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (case
                                                                           "x!1>1")
                                                                          (("1"
                                                                            (mult-by
                                                                             -1
                                                                             "gcd(cc,dd)")
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (case
                                                                             "x!1 <=0")
                                                                            (("1"
                                                                              (lemma
                                                                               "nnreal_times_nnreal_is_nnreal")
                                                                              (("1"
                                                                                (inst
                                                                                 -
                                                                                 "-x!1"
                                                                                 "gcd(cc,dd)")
                                                                                (("1"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil)
                                                                                 ("2"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (case
                                                         "FORALL (nnz,xxz,ccz,rrz:int): divides(rrz,xxz) AND divides(rrz,ccz) IMPLIES divides(rrz,nnz*xxz+ccz)")
                                                        (("1"
                                                          (inst-cp
                                                           -
                                                           "nn"
                                                           "xx"
                                                           "dd"
                                                           "gcd(cc,dd)")
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (inst
                                                               -
                                                               "mm"
                                                               "xx"
                                                               "cc"
                                                               "gcd(cc,dd)")
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (hide-all-but
                                                           1)
                                                          (("2"
                                                            (skeep)
                                                            (("2"
                                                              (expand
                                                               "divides")
                                                              (("2"
                                                                (skosimp*)
                                                                (("2"
                                                                  (replace
                                                                   -1)
                                                                  (("2"
                                                                    (replace
                                                                     -2)
                                                                    (("2"
                                                                      (inst
                                                                       +
                                                                       "nnz*x!1+x!2")
                                                                      (("2"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (postpone)
                                                    nil
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (postpone)
                                                  nil
                                                  nil)
                                                 ("3"
                                                  (postpone)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2" (postpone) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (postpone) nil nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   nil shostak))
 (fermat_prime_sos_finite_set 0
  (fermat_prime_sos_finite_set-1 nil 3539964928
   (""
    (case "FORALL (ig:nat,ez1,pr2:int): abs(ez1)<ig AND pr2/=0 IMPLIES ez1/=ig*pr2")
    (("1" (label "lem1" -1)
      (("1" (hide "lem1")
        (("1" (skeep)
          (("1"
            (name "CC" "LAMBDA (x,y,z:nat): x<=p AND y<=p AND z<=p")
            (("1" (case "finite_sets[[nat, nat, nat]].is_finite(CC)")
              (("1"
                (case "EXISTS (FF:[(fermat_prime_sos_set(p)) -> (CC)]): injective?(FF)")
                (("1" (skeep -1)
                  (("1" (expand "is_finite")
                    (("1" (skosimp*)
                      (("1" (inst + "N!1" "f!1 o FF")
                        (("1"
                          (lemma
                           "composition_injective[(fermat_prime_sos_set(p)),(CC),below(N!1)]")
                          (("1" (inst - "FF" "f!1")
                            (("1" (assertnil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (hide-all-but 1)
                  (("2"
                    (inst +
                     "LAMBDA (xyz:(fermat_prime_sos_set(p))): xyz")
                    (("1" (expand "injective?")
                      (("1" (skosimp*) nil nil)) nil)
                     ("2" (skosimp*)
                      (("2" (expand "CC")
                        (("2" (typepred "xyz!1")
                          (("2" (expand "fermat_prime_sos_set")
                            (("2"
                              (case "xyz!1`1 >= 1 AND xyz!1`2 >= 1 AND xyz!1`3 >= 1")
                              (("1"
                                (flatten)
                                (("1"
                                  (copy -1)
                                  (("1"
                                    (mult-by -1 "xyz!1`1")
                                    (("1"
                                      (copy -3)
                                      (("1"
                                        (mult-by -1 "xyz!1`3")
                                        (("1"
                                          (copy -5)
                                          (("1"
                                            (mult-by -1 "xyz!1`2")
                                            (("1"
                                              (assert)
                                              (("1"
                                                (expand "^")
                                                (("1"
                                                  (expand "expt")
                                                  (("1"
                                                    (expand "expt")
                                                    (("1"
                                                      (expand "expt")
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide 2)
                                (("2"
                                  (case "xyz!1`1 = 0")
                                  (("1"
                                    (assert)
                                    (("1"
                                      (hide +)
                                      (("1"
                                        (grind)
                                        (("1"
                                          (typepred "p")
                                          (("1"
                                            (expand "prime?")
                                            (("1"
                                              (flatten)
                                              (("1"
                                                (inst - "2")
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (inst
                                                     +
                                                     "2*xyz!1`2*xyz!1`3")
                                                    (("1"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (case "xyz!1`2 = 0 OR xyz!1`3 = 0")
                                    (("1"
                                      (case "xyz!1`2 * xyz!1`3 = 0")
                                      (("1"
                                        (replace -1)
                                        (("1"
                                          (hide (-1 -2))
                                          (("1"
                                            (assert)
                                            (("1"
                                              (typepred "p")
                                              (("1"
                                                (expand "prime?")
                                                (("1"
                                                  (flatten)
                                                  (("1"
                                                    (inst - "xyz!1`1")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (split -)
                                                        (("1"
                                                          (expand
                                                           "divides")
                                                          (("1"
                                                            (inst
                                                             +
                                                             "xyz!1`1")
                                                            (("1"
                                                              (grind)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (flatten)
                                                          (("2"
                                                            (replace
                                                             -1)
                                                            (("2"
                                                              (grind)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("3"
                                                          (flatten)
                                                          (("3"
                                                            (assert)
                                                            (("3"
                                                              (replace
                                                               -1)
                                                              (("3"
                                                                (case
                                                                 "p > 1")
                                                                (("1"
                                                                  (mult-by
                                                                   -1
                                                                   "p")
                                                                  (("1"
                                                                    (grind)
                                                                    nil
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (propax)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2" (ground) nil nil))
                                      nil)
                                     ("2" (ground) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (hide-all-but 1)
                (("2" (expand "is_finite")
                  (("2"
                    (inst + "(p+1)^3"
                     "LAMBDA (xyz:(CC)): LET x = xyz`1, y = xyz`2, z = xyz`3 IN x*(p+1)^2 + y*(p+1) + z")
                    (("1" (expand "injective?")
                      (("1" (skeep)
                        (("1" (label "hyp" -1)
                          (("1" (typepred "x1")
                            (("1" (typepred "x2")
                              (("1"
                                (expand "CC")
                                (("1"
                                  (flatten)
                                  (("1"
                                    (case "x1`3=x2`3")
                                    (("1"
                                      (replace -1)
                                      (("1"
                                        (assert)
                                        (("1"
                                          (case "x1`2 = x2`2")
                                          (("1"
                                            (replace -1)
                                            (("1"
                                              (assert)
                                              (("1"
                                                (case "(1+p)^2 > 0")
                                                (("1"
                                                  (copy "hyp")
                                                  (("1"
                                                    (case
                                                     "x1`1 = x2`1")
                                                    (("1"
                                                      (decompose-equality
                                                       +)
                                                      nil
                                                      nil)
                                                     ("2"
                                                      (hide 2)
                                                      (("2"
                                                        (mult-by
                                                         -1
                                                         "1/(1+p)^2")
                                                        (("2"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (lemma
                                                   "posreal_times_posreal_is_posreal")
                                                  (("2"
                                                    (hide-all-but
                                                     (-1 1))
                                                    (("2"
                                                      (inst
                                                       -
                                                       "1+p"
                                                       "1+p")
                                                      (("2"
                                                        (grind)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (case
                                             "(x1`1-x2`1)*(1+p) = x2`2 - x1`2")
                                            (("1"
                                              (reveal "lem1")
                                              (("1"
                                                (inst
                                                 -
                                                 "1+p"
                                                 "x2`2-x1`2"
                                                 "x1`1-x2`1")
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (expand "abs")
                                                    (("1"
                                                      (lift-if)
                                                      (("1"
                                                        (ground)
--> --------------------

--> maximum size reached

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

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.958Bemerkung:  (vorverarbeitet am  2026-04-27) ¤

*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