Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/PVS/Sturm/   (Beweissystem der NASA Version 6.0.9©)  Datei vom 6.10.2014 mit Größe 1 MB image not shown  

Impressum sturm.prf

  Sprache: Lisp
 

(sturm
 (constructed_sturm_sequence?_TCC1 0
  (constructed_sturm_sequence?_TCC1-1 nil 3589569590
   ("" (skeep)
    (("" (skeep)
      (("" (inst - "j1-2" "j1-1")
        (("1" (assertnil nil) ("2" (assertnil nil)
         ("3" (assertnil nil))
        nil))
      nil))
    nil)
   ((real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (below type-eq-decl nil naturalnumbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (AND const-decl "[bool, 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)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields 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)
    (j1 skolem-const-decl "nat" sturm nil)
    (< const-decl "bool" reals nil)
    (m skolem-const-decl "nat" sturm nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_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))
   nil))
 (constructed_sturm_sequence?_TCC2 0
  (constructed_sturm_sequence?_TCC2-1 nil 3589569590
   ("" (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)
    (< const-decl "bool" reals nil)
    (below type-eq-decl nil naturalnumbers nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields 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)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (/= const-decl "boolean" notequal nil))
   nil))
 (constructed_sturm_sequence?_TCC3 0
  (constructed_sturm_sequence?_TCC3-1 nil 3589569590
   ("" (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)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (/= const-decl "boolean" notequal nil))
   nil))
 (constructed_sturm_seq_repeated_root 0
  (constructed_sturm_seq_repeated_root-1 nil 3589570933
   ("" (skeep)
    ((""
      (case "FORALL (i:nat): i-1>=0 AND i+1<=m AND polynomial(p(i),n(i))(x)=0 IMPLIES (polynomial(p(i-1),n(i-1))(x)=0 IFF polynomial(p(i+1),n(i+1))(x)=0)")
      (("1" (skeep)
        (("1"
          (case "FORALL (j:nat): i-j>=0 IMPLIES FORALL (k:nat): k<=j IMPLIES polynomial(p(i-k), n(i-k))(x) = 0")
          (("1"
            (case "FORALL (j:nat): i+j<=m IMPLIES FORALL (k:nat): k<=j IMPLIES  polynomial(p(i+k), n(i+k))(x) = 0")
            (("1" (skeep)
              (("1" (case "j>=i")
                (("1" (inst - "j-i")
                  (("1" (assert)
                    (("1" (inst - "j-i") (("1" (assertnil nil)) nil))
                    nil)
                   ("2" (assertnil nil))
                  nil)
                 ("2" (inst -2 "i-j")
                  (("1" (assert)
                    (("1" (inst -2 "i-j") (("1" (assertnil nil))
                      nil))
                    nil)
                   ("2" (assertnil nil))
                  nil))
                nil))
              nil)
             ("2" (hide (-1 2))
              (("2" (induct "j")
                (("1" (assert)
                  (("1" (skeep) (("1" (assertnil nil)) nil)) nil)
                 ("2" (assert)
                  (("2" (skosimp*)
                    (("2" (assert)
                      (("2" (case "k!1=0 OR k!1=1")
                        (("1" (ground) nil nil)
                         ("2" (flatten)
                          (("2" (inst-cp - "k!1-1")
                            (("2" (inst - "k!1-2")
                              (("1"
                                (assert)
                                (("1"
                                  (assert)
                                  (("1"
                                    (inst - "i-1+k!1")
                                    (("1" (assertnil nil))
                                    nil))
                                  nil))
                                nil)
                               ("2" (assertnil nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (hide 2)
            (("2" (induct "j")
              (("1" (assert)
                (("1" (skosimp*) (("1" (assertnil nil)) nil)) nil)
               ("2" (skosimp*)
                (("2" (assert)
                  (("2" (case "k!1=0")
                    (("1" (assertnil nil)
                     ("2" (assert)
                      (("2" (inst-cp - "k!1-1")
                        (("2" (case "k!1=1")
                          (("1" (hide -2)
                            (("1" (assert)
                              (("1"
                                (inst - "i")
                                (("1" (assertnil nil))
                                nil))
                              nil))
                            nil)
                           ("2" (inst - "k!1-2")
                            (("1" (assert)
                              (("1"
                                (inst - "i-k!1+1")
                                (("1" (assertnil nil))
                                nil))
                              nil)
                             ("2" (assertnil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("3" (skosimp*) (("3" (assertnil nil)) nil)
               ("4" (assert)
                (("4" (skosimp*) (("4" (assertnil nil)) nil)) nil)
               ("5" (skosimp*) (("5" (assertnil nil)) nil)
               ("6" (skosimp*) (("6" (assertnil nil)) nil)
               ("7" (skosimp*) (("7" (assertnil nil)) nil))
              nil))
            nil)
           ("3" (skosimp*) (("3" (assertnil nil)) nil))
          nil))
        nil)
       ("2" (hide 2)
        (("2" (skeep)
          (("2" (assert)
            (("2" (expand "constructed_sturm_sequence?")
              (("2" (flatten)
                (("2" (inst -10 "1+i")
                  (("2" (assert)
                    (("2" (skeep)
                      (("2"
                        (name "pd"
                              "poly_divide(p(i - 1), n(i - 1))(p(i), n(i))(0)")
                        (("2" (lemma "poly_divide_def")
                          (("2" (inst?)
                            (("2" (assert)
                              (("2"
                                (replace -2)
                                (("2"
                                  (assert)
                                  (("2"
                                    (inst - "i")
                                    (("2"
                                      (assert)
                                      (("2"
                                        (inst - "i-1" "i")
                                        (("2"
                                          (assert)
                                          (("2"
                                            (assert)
                                            (("2"
                                              (inst - "x")
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (replace -1)
                                                  (("2"
                                                    (replace -5)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (case
                                                         "polynomial(pd`rem, pd`rdeg)(x) = 0 IFF polynomial(-c*pd`rem, pd`rdeg)(x) = 0")
                                                        (("1"
                                                          (replace
                                                           -1
                                                           +)
                                                          (("1"
                                                            (replace
                                                             -13
                                                             +
                                                             :dir
                                                             rl)
                                                            (("1"
                                                              (ground)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (hide-all-but
                                                           1)
                                                          (("2"
                                                            (rewrite
                                                             "scal_polynomial2")
                                                            (("2"
                                                              (ground)
                                                              (("2"
                                                                (mult-by
                                                                 1
                                                                 "c")
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((IFF const-decl "[bool, bool -> bool]" booleans nil)
    (polynomial const-decl "[real -> real]" polynomials "reals/")
    (sequence type-eq-decl nil sequences nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (<= const-decl "bool" reals nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (k!1 skolem-const-decl "nat" sturm nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (m skolem-const-decl "nat" sturm nil)
    (j skolem-const-decl "upto(m)" sturm nil)
    (i skolem-const-decl "nat" sturm nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (k!1 skolem-const-decl "nat" sturm nil)
    (constructed_sturm_sequence? const-decl "bool" sturm nil)
    (poly_divide_def formula-decl nil polynomial_division nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (minus_nzreal_is_nzreal application-judgement "nzreal" real_types
     nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (* const-decl "[T -> real]" real_fun_ops "reals/")
    (- const-decl "[numfield -> numfield]" number_fields 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)
    (scal_polynomial2 formula-decl nil polynomials "reals/")
    (both_sides_times1 formula-decl nil real_props nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (nnreal_times_nnreal_is_nnreal application-judgement "nnreal"
     real_types nil)
    (< const-decl "bool" reals nil)
    (below type-eq-decl nil naturalnumbers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (poly_divide def-decl "DivType" polynomial_division nil)
    (/= const-decl "boolean" notequal nil)
    (DivType type-eq-decl nil polynomial_division nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   nil))
 (constructed_sturm_seq_repeated_root_mth 0
  (constructed_sturm_seq_repeated_root_mth-1 nil 3591517436
   ("" (induct "i")
    (("1" (skeep)
      (("1" (skeep) (("1" (inst + "mm") (("1" (assertnil nil)) nil))
        nil))
      nil)
     ("2" (skolem 1 "i")
      (("2" (flatten)
        (("2" (skeep)
          (("2" (inst?)
            (("2" (inst?)
              (("2" (assert)
                (("2" (skeep)
                  (("2" (case "u/=i+1")
                    (("1" (inst - "u") (("1" (assertnil nil)) nil)
                     ("2" (flatten)
                      (("2" (replace -1)
                        (("2" (assert)
                          (("2" (case "i = 0")
                            (("1" (replace -1)
                              (("1"
                                (assert)
                                (("1"
                                  (inst + "mm-1")
                                  (("1"
                                    (assert)
                                    (("1"
                                      (lemma
                                       "max_linear_div_power_derivative")
                                      (("1"
                                        (inst?)
                                        (("1"
                                          (assert)
                                          (("1"
                                            (flatten)
                                            (("1"
                                              (expand
                                               "constructed_sturm_sequence?")
                                              (("1"
                                                (flatten)
                                                (("1"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (label "css" -3)
                              (("2"
                                (copy "css")
                                (("2"
                                  (expand
                                   "constructed_sturm_sequence?"
                                   -1)
                                  (("2"
                                    (flatten)
                                    (("2"
                                      (hide (-1 -2 -3 -4 -5 -6))
                                      (("2"
                                        (inst - "1+i")
                                        (("2"
                                          (assert)
                                          (("2"
                                            (skeep)
                                            (("2"
                                              (name
                                               "pd"
                                               "poly_divide(p(i - 1), n(i - 1))(p(i), n(i))(0)")
                                              (("2"
                                                (replace -1)
                                                (("2"
                                                  (lemma
                                                   "polynomial_degree_existence")
                                                  (("2"
                                                    (inst
                                                     -
                                                     "pd`rem"
                                                     "pd`rdeg")
                                                    (("2"
                                                      (split -)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (skolem
                                                           -1
                                                           "RD")
                                                          (("1"
                                                            (flatten)
                                                            (("1"
                                                              (case
                                                               "EXISTS (kp: posnat):
                                  kp >= mm - 1 AND max_linear_div_power?(pd`rem,RD, y)(kp)")
                                                              (("1"
                                                                (skeep
                                                                 -)
                                                                (("1"
                                                                  (lemma
                                                                   "max_linear_div_power_scal")
                                                                  (("1"
                                                                    (inst
                                                                     -
                                                                     "pd`rem"
                                                                     "RD"
                                                                     "y"
                                                                     "-c"
                                                                     "kp")
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (case
                                                                         "polynomial(-c * pd`rem, pd`rdeg) = polynomial(-c*pd`rem,RD)")
                                                                        (("1"
                                                                          (replace
                                                                           -1)
                                                                          (("1"
                                                                            (lemma
                                                                             "poly_divide_lengths")
                                                                            (("1"
                                                                              (inst?)
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (replace
                                                                                   -8)
                                                                                  (("1"
                                                                                    (split
                                                                                     -1)
                                                                                    (("1"
                                                                                      (flatten)
                                                                                      (("1"
                                                                                        (assert)
                                                                                        (("1"
                                                                                          (case
                                                                                           "n(i)=0")
                                                                                          (("1"
                                                                                            (copy
                                                                                             "css")
                                                                                            (("1"
                                                                                              (expand
                                                                                               "constructed_sturm_sequence?"
                                                                                               -1)
                                                                                              (("1"
                                                                                                (flatten)
                                                                                                (("1"
                                                                                                  (inst
                                                                                                   -
                                                                                                   "i"
                                                                                                   "i+1")
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    nil
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (assert)
                                                                                            (("2"
                                                                                              (rewrite
                                                                                               "max_linear_div_power_rew2"
                                                                                               -4)
                                                                                              (("2"
                                                                                                (inst
                                                                                                 +
                                                                                                 "kp")
                                                                                                (("2"
                                                                                                  (assert)
                                                                                                  (("2"
                                                                                                    (rewrite
                                                                                                     "max_linear_div_power_rew2"
                                                                                                     +)
                                                                                                    (("2"
                                                                                                      (assert)
                                                                                                      (("2"
                                                                                                        (replace
                                                                                                         -10)
                                                                                                        (("2"
                                                                                                          (propax)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (copy
                                                                                       "css")
                                                                                      (("2"
                                                                                        (expand
                                                                                         "constructed_sturm_sequence?"
                                                                                         -1)
                                                                                        (("2"
                                                                                          (flatten)
                                                                                          (("2"
                                                                                            (inst
                                                                                             -
                                                                                             "i")
                                                                                            (("2"
                                                                                              (assert)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("3"
                                                                                      (copy
                                                                                       "css")
                                                                                      (("3"
                                                                                        (expand
                                                                                         "constructed_sturm_sequence?"
                                                                                         -1)
                                                                                        (("3"
                                                                                          (flatten)
                                                                                          (("3"
                                                                                            (inst
                                                                                             -
                                                                                             "i-1"
                                                                                             "i")
                                                                                            (("3"
                                                                                              (assert)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("4"
                                                                                      (copy
                                                                                       "css")
                                                                                      (("4"
                                                                                        (expand
                                                                                         "constructed_sturm_sequence?"
                                                                                         -1)
                                                                                        (("4"
                                                                                          (flatten)
                                                                                          (("4"
                                                                                            (inst
                                                                                             -
                                                                                             "i-1"
                                                                                             "i")
                                                                                            (("4"
                                                                                              (assert)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (expand
                                                                           "polynomial"
                                                                           +
                                                                           1)
                                                                          (("2"
                                                                            (decompose-equality
                                                                             1)
                                                                            (("2"
                                                                              (lemma
                                                                               "sigma_split")
                                                                              (("2"
                                                                                (inst?)
                                                                                (("2"
                                                                                  (inst
                                                                                   -
                                                                                   "RD")
                                                                                  (("2"
                                                                                    (assert)
                                                                                    (("2"
                                                                                      (replaces
                                                                                       -1)
                                                                                      (("2"
                                                                                        (invoke
                                                                                         (case
                                                                                          "%1 = 0")
                                                                                         (!
                                                                                          1
                                                                                          1
                                                                                          2))
                                                                                        (("1"
                                                                                          (replaces
                                                                                           -1)
                                                                                          (("1"
                                                                                            (assert)
                                                                                            (("1"
                                                                                              (expand
                                                                                               "polynomial"
                                                                                               1)
                                                                                              (("1"
                                                                                                (propax)
                                                                                                nil
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (hide
                                                                                           2)
                                                                                          (("2"
                                                                                            (rewrite
                                                                                             "sigma_restrict_eq_0")
                                                                                            (("2"
                                                                                              (skosimp*)
                                                                                              (("2"
                                                                                                (expand
                                                                                                 "*")
                                                                                                (("2"
                                                                                                  (inst
                                                                                                   -
                                                                                                   "i!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
                                                                 4)
                                                                (("2"
                                                                  (lemma
                                                                   "poly_divide_def")
                                                                  (("2"
                                                                    (inst?)
                                                                    (("2"
                                                                      (assert)
                                                                      (("2"
                                                                        (split
                                                                         -)
                                                                        (("1"
                                                                          (replace
                                                                           -4)
                                                                          (("1"
                                                                            (label
                                                                             "IG"
                                                                             -7)
                                                                            (("1"
                                                                              (copy
                                                                               "IG")
                                                                              (("1"
                                                                                (inst-cp
                                                                                 -
                                                                                 "i")
                                                                                (("1"
                                                                                  (inst
                                                                                   -
                                                                                   "i-1")
                                                                                  (("1"
                                                                                    (assert)
                                                                                    (("1"
                                                                                      (skolem
                                                                                       -1
                                                                                       "Ai")
                                                                                      (("1"
                                                                                        (skolem
                                                                                         -
                                                                                         "Bi")
                                                                                        (("1"
                                                                                          (assert)
                                                                                          (("1"
                                                                                            (flatten)
                                                                                            (("1"
                                                                                              (rewrite
                                                                                               "max_linear_div_power_rew2"
                                                                                               -)
                                                                                              (("1"
                                                                                                (rewrite
                                                                                                 "max_linear_div_power_rew2"
                                                                                                 -)
                                                                                                (("1"
                                                                                                  (skosimp*)
                                                                                                  (("1"
                                                                                                    (case
                                                                                                     "EXISTS (bb:[nat->real],kk:nat): FORALL (x): polynomial(pd`rem, RD)(x) = (x-y)^(mm-1)*polynomial(bb,kk)(x)")
                                                                                                    (("1"
                                                                                                      (skeep)
                                                                                                      (("1"
                                                                                                        (case
                                                                                                         "polynomial(bb,kk)(y)/=0")
                                                                                                        (("1"
                                                                                                          (inst
                                                                                                           +
                                                                                                           "mm-1")
                                                                                                          (("1"
                                                                                                            (assert)
                                                                                                            (("1"
                                                                                                              (rewrite
                                                                                                               "max_linear_div_power_rew2"
                                                                                                               +)
                                                                                                              (("1"
                                                                                                                (inst
                                                                                                                 +
                                                                                                                 "bb"
                                                                                                                 "kk")
                                                                                                                (("1"
                                                                                                                  (assert)
                                                                                                                  nil
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (flatten)
                                                                                                          (("2"
                                                                                                            (assert)
                                                                                                            (("2"
                                                                                                              (lemma
                                                                                                               "polynomial_degree_existence")
                                                                                                              (("2"
                                                                                                                (inst
                                                                                                                 -
                                                                                                                 "bb"
                                                                                                                 "kk")
                                                                                                                (("2"
                                                                                                                  (split
                                                                                                                   -)
                                                                                                                  (("1"
                                                                                                                    (skosimp*)
                                                                                                                    (("1"
                                                                                                                      (name
                                                                                                                       "DV"
                                                                                                                       "i!1")
                                                                                                                      (("1"
                                                                                                                        (replaces
                                                                                                                         -1)
                                                                                                                        (("1"
                                                                                                                          (assert)
                                                                                                                          (("1"
                                                                                                                            (replaces
                                                                                                                             -2)
                                                                                                                            (("1"
                                                                                                                              (assert)
                                                                                                                              (("1"
                                                                                                                                (lemma
                                                                                                                                 "poly_max_zero_power")
                                                                                                                                (("1"
                                                                                                                                  (inst
                                                                                                                                   -
                                                                                                                                   "bb"
                                                                                                                                   "DV"
                                                                                                                                   "y")
                                                                                                                                  (("1"
                                                                                                                                    (assert)
                                                                                                                                    (("1"
                                                                                                                                      (skolem
                                                                                                                                       -1
                                                                                                                                       "M")
                                                                                                                                      (("1"
                                                                                                                                        (inst
                                                                                                                                         +
                                                                                                                                         "M + mm-1")
                                                                                                                                        (("1"
                                                                                                                                          (assert)
                                                                                                                                          (("1"
                                                                                                                                            (lemma
                                                                                                                                             "max_linear_div_power_additive")
                                                                                                                                            (("1"
                                                                                                                                              (inst
                                                                                                                                               -
                                                                                                                                               "pd`rem"
                                                                                                                                               "RD"
                                                                                                                                               "y"
                                                                                                                                               "mm-1"
                                                                                                                                               "M"
                                                                                                                                               "bb"
                                                                                                                                               "DV")
                                                                                                                                              (("1"
                                                                                                                                                (assert)
                                                                                                                                                nil
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil)
                                                                                                                   ("2"
                                                                                                                    (flatten)
                                                                                                                    (("2"
                                                                                                                      (case
                                                                                                                       "NOT polynomial(bb,kk) = (LAMBDA (x): 0)")
                                                                                                                      (("1"
                                                                                                                        (decompose-equality
                                                                                                                         1)
                                                                                                                        (("1"
                                                                                                                          (inst
                                                                                                                           +
                                                                                                                           "x!1")
                                                                                                                          (("1"
                                                                                                                            (assert)
                                                                                                                            nil
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil)
                                                                                                                       ("2"
                                                                                                                        (replaces
                                                                                                                         -1)
                                                                                                                        (("2"
                                                                                                                          (assert)
                                                                                                                          (("2"
                                                                                                                            (lemma
                                                                                                                             "polynomial_eq_coeff")
                                                                                                                            (("2"
                                                                                                                              (inst
                                                                                                                               -
                                                                                                                               "pd`rem"
                                                                                                                               "LAMBDA (i:nat): 0"
                                                                                                                               "RD")
                                                                                                                              (("2"
                                                                                                                                (flatten)
                                                                                                                                (("2"
                                                                                                                                  (hide
                                                                                                                                   -2)
                                                                                                                                  (("2"
                                                                                                                                    (split
                                                                                                                                     -)
                                                                                                                                    (("1"
                                                                                                                                      (inst
                                                                                                                                       -
                                                                                                                                       "RD")
                                                                                                                                      nil
                                                                                                                                      nil)
                                                                                                                                     ("2"
                                                                                                                                      (decompose-equality
                                                                                                                                       1)
                                                                                                                                      (("2"
                                                                                                                                        (inst
                                                                                                                                         -
                                                                                                                                         "x!1")
                                                                                                                                        (("2"
                                                                                                                                          (replaces
                                                                                                                                           -2)
                                                                                                                                          (("2"
                                                                                                                                            (expand
                                                                                                                                             "polynomial"
                                                                                                                                             1)
                                                                                                                                            (("2"
                                                                                                                                              (rewrite
                                                                                                                                               "sigma_restrict_eq_0")
                                                                                                                                              (("2"
                                                                                                                                                (skosimp*)
                                                                                                                                                (("2"
                                                                                                                                                  (lift-if)
                                                                                                                                                  (("2"
                                                                                                                                                    (ground)
                                                                                                                                                    nil
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (hide
                                                                                                       4)
                                                                                                      (("2"
                                                                                                        (replace
                                                                                                         -7
                                                                                                         +
                                                                                                         :dir
                                                                                                         rl)
                                                                                                        (("2"
                                                                                                          (case
                                                                                                           "NOT polynomial(pd`rem,pd`rdeg) = (LAMBDA (x): polynomial(p(i - 1), n(i - 1))(x) -
          polynomial(pd`quot, pd`qdeg)(x) * polynomial(p(i), n(i))(x))")
                                                                                                          (("1"
                                                                                                            (decompose-equality
                                                                                                             1)
                                                                                                            (("1"
                                                                                                              (inst
                                                                                                               -
                                                                                                               "x!1")
                                                                                                              (("1"
                                                                                                                (inst
                                                                                                                 -
                                                                                                                 "x!1")
                                                                                                                (("1"
                                                                                                                  (inst
                                                                                                                   -
                                                                                                                   "x!1")
                                                                                                                  (("1"
                                                                                                                    (assert)
                                                                                                                    nil
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil)
                                                                                                           ("2"
                                                                                                            (replace
                                                                                                             -1
                                                                                                             +)
                                                                                                            (("2"
                                                                                                              (assert)
                                                                                                              (("2"
                                                                                                                (lemma
                                                                                                                 "div_linear_power_reduces")
                                                                                                                (("2"
                                                                                                                  (inst
                                                                                                                   -
                                                                                                                   "p(i-1)"
                                                                                                                   "n(i-1)"
                                                                                                                   "y"
                                                                                                                   "b!1"
                                                                                                                   "Ai"
                                                                                                                   "k!1"
                                                                                                                   "mm-1")
                                                                                                                  (("2"
                                                                                                                    (assert)
                                                                                                                    (("2"
                                                                                                                      (replace
                                                                                                                       -4)
                                                                                                                      (("2"
                                                                                                                        (lemma
                                                                                                                         "div_linear_power_reduces")
                                                                                                                        (("2"
                                                                                                                          (inst
                                                                                                                           -
                                                                                                                           "p(i)"
                                                                                                                           "n(i)"
                                                                                                                           "y"
                                                                                                                           "b!2"
                                                                                                                           "Bi"
                                                                                                                           "k!2"
                                                                                                                           "mm-1")
                                                                                                                          (("2"
                                                                                                                            (assert)
                                                                                                                            (("2"
                                                                                                                              (replace
                                                                                                                               -7)
                                                                                                                              (("2"
                                                                                                                                (skosimp*)
                                                                                                                                (("2"
                                                                                                                                  (name
                                                                                                                                   "DV"
                                                                                                                                   "polynomial_prod(pd`quot,pd`qdeg,bb!1,q!1)")
                                                                                                                                  (("2"
                                                                                                                                    (name
                                                                                                                                     "G1"
                                                                                                                                     "LAMBDA (i:nat): IF i<=pd`qdeg+q!1 THEN DV(i) ELSE 0 ENDIF")
                                                                                                                                    (("2"
                                                                                                                                      (name
                                                                                                                                       "G2"
                                                                                                                                       "LAMBDA (i:nat): IF i<=q!2 THEN bb!2(i) ELSE 0 ENDIF")
                                                                                                                                      (("2"
                                                                                                                                        (inst
                                                                                                                                         +
                                                                                                                                         "G2 - G1"
                                                                                                                                         "pd`qdeg+q!1+q!2")
                                                                                                                                        (("2"
                                                                                                                                          (skeep)
                                                                                                                                          (("2"
                                                                                                                                            (inst
                                                                                                                                             -
                                                                                                                                             "x")
                                                                                                                                            (("2"
                                                                                                                                              (inst
                                                                                                                                               -
                                                                                                                                               "x")
                                                                                                                                              (("2"
                                                                                                                                                (replace
                                                                                                                                                 -4
                                                                                                                                                 +)
                                                                                                                                                (("2"
                                                                                                                                                  (replace
                                                                                                                                                   -5
                                                                                                                                                   +)
                                                                                                                                                  (("2"
                                                                                                                                                    (case
                                                                                                                                                     " polynomial(bb!2, q!2)(x) -
       polynomial(pd`quot, pd`qdeg)(x) * polynomial(bb!1, q!1)(x)
       = polynomial(G2 - G1, pd`qdeg + q!1 + q!2)(x)")
                                                                                                                                                    (("1"
                                                                                                                                                      (assert)
                                                                                                                                                      (("1"
                                                                                                                                                        (replace
                                                                                                                                                         -1
                                                                                                                                                         +
                                                                                                                                                         :dir
                                                                                                                                                         rl)
                                                                                                                                                        (("1"
                                                                                                                                                          (assert)
                                                                                                                                                          (("1"
                                                                                                                                                            (hide-all-but
                                                                                                                                                             1)
                                                                                                                                                            (("1"
                                                                                                                                                              (grind
                                                                                                                                                               :exclude
                                                                                                                                                               "polynomial")
                                                                                                                                                              nil
                                                                                                                                                              nil))
                                                                                                                                                            nil))
                                                                                                                                                          nil))
                                                                                                                                                        nil))
                                                                                                                                                      nil)
                                                                                                                                                     ("2"
                                                                                                                                                      (hide
                                                                                                                                                       2)
                                                                                                                                                      (("2"
                                                                                                                                                        (rewrite
                                                                                                                                                         "polynomial_sub")
                                                                                                                                                        (("2"
                                                                                                                                                          (expand
                                                                                                                                                           "-")
                                                                                                                                                          (("2"
                                                                                                                                                            (case
                                                                                                                                                             "polynomial(bb!2, q!2)(x) 
       =
       polynomial(G2, pd`qdeg + q!1 + q!2)(x)")
                                                                                                                                                            (("1"
                                                                                                                                                              (replace
                                                                                                                                                               -1
                                                                                                                                                               :dir
                                                                                                                                                               rl)
                                                                                                                                                              (("1"
                                                                                                                                                                (assert)
                                                                                                                                                                (("1"
                                                                                                                                                                  (rewrite
                                                                                                                                                                   "polynomial_prod_def"
                                                                                                                                                                   1)
                                                                                                                                                                  (("1"
                                                                                                                                                                    (replace
                                                                                                                                                                     -4)
                                                                                                                                                                    (("1"
                                                                                                                                                                      (expand
                                                                                                                                                                       "polynomial"
                                                                                                                                                                       +
                                                                                                                                                                       2)
                                                                                                                                                                      (("1"
                                                                                                                                                                        (lemma
                                                                                                                                                                         "sigma_split")
                                                                                                                                                                        (("1"
                                                                                                                                                                          (inst?)
                                                                                                                                                                          (("1"
                                                                                                                                                                            (inst
                                                                                                                                                                             -
                                                                                                                                                                             "pd`qdeg + q!1")
                                                                                                                                                                            (("1"
                                                                                                                                                                              (assert)
                                                                                                                                                                              (("1"
                                                                                                                                                                                (replaces
                                                                                                                                                                                 -1)
                                                                                                                                                                                (("1"
                                                                                                                                                                                  (assert)
                                                                                                                                                                                  (("1"
                                                                                                                                                                                    (invoke
                                                                                                                                                                                     (case
                                                                                                                                                                                      "%1 = 0")
                                                                                                                                                                                     (!
                                                                                                                                                                                      1
                                                                                                                                                                                      2
                                                                                                                                                                                      2))
                                                                                                                                                                                    (("1"
                                                                                                                                                                                      (replaces
                                                                                                                                                                                       -1)
                                                                                                                                                                                      (("1"
                                                                                                                                                                                        (assert)
                                                                                                                                                                                        (("1"
                                                                                                                                                                                          (assert)
                                                                                                                                                                                          (("1"
                                                                                                                                                                                            (case
                                                                                                                                                                                             "FORALL (AB1,AB2:real): AB1=AB2 IMPLIES -1*AB1 = 0-AB2")
                                                                                                                                                                                            (("1"
                                                                                                                                                                                              (inst?)
                                                                                                                                                                                              (("1"
                                                                                                                                                                                                (split
                                                                                                                                                                                                 -)
                                                                                                                                                                                                (("1"
                                                                                                                                                                                                  (assert)
                                                                                                                                                                                                  nil
                                                                                                                                                                                                  nil)
                                                                                                                                                                                                 ("2"
                                                                                                                                                                                                  (hide
                                                                                                                                                                                                   2)
                                                                                                                                                                                                  (("2"
                                                                                                                                                                                                    (expand
                                                                                                                                                                                                     "polynomial"
                                                                                                                                                                                                     1)
                                                                                                                                                                                                    (("2"
                                                                                                                                                                                                      (rewrite
                                                                                                                                                                                                       "sigma_eq")
                                                                                                                                                                                                      (("2"
                                                                                                                                                                                                        (skosimp*)
                                                                                                                                                                                                        (("2"
                                                                                                                                                                                                          (expand
                                                                                                                                                                                                           "G1"
                                                                                                                                                                                                           1)
                                                                                                                                                                                                          (("2"
                                                                                                                                                                                                            (propax)
                                                                                                                                                                                                            nil
                                                                                                                                                                                                            nil))
                                                                                                                                                                                                          nil))
                                                                                                                                                                                                        nil))
                                                                                                                                                                                                      nil))
                                                                                                                                                                                                    nil))
                                                                                                                                                                                                  nil))
                                                                                                                                                                                                nil))
                                                                                                                                                                                              nil)
                                                                                                                                                                                             ("2"
                                                                                                                                                                                              (assert)
                                                                                                                                                                                              (("2"
                                                                                                                                                                                                (skosimp*)
                                                                                                                                                                                                (("2"
                                                                                                                                                                                                  (assert)
                                                                                                                                                                                                  nil
                                                                                                                                                                                                  nil))
                                                                                                                                                                                                nil))
                                                                                                                                                                                              nil))
                                                                                                                                                                                            nil))
                                                                                                                                                                                          nil))
                                                                                                                                                                                        nil))
                                                                                                                                                                                      nil)
                                                                                                                                                                                     ("2"
                                                                                                                                                                                      (rewrite
                                                                                                                                                                                       "sigma_restrict_eq_0")
                                                                                                                                                                                      (("2"
                                                                                                                                                                                        (skosimp*)
                                                                                                                                                                                        (("2"
                                                                                                                                                                                          (expand
                                                                                                                                                                                           "G1"
                                                                                                                                                                                           1)
                                                                                                                                                                                          (("2"
                                                                                                                                                                                            (assert)
                                                                                                                                                                                            nil
                                                                                                                                                                                            nil))
                                                                                                                                                                                          nil))
                                                                                                                                                                                        nil))
                                                                                                                                                                                      nil))
                                                                                                                                                                                    nil))
                                                                                                                                                                                  nil))
                                                                                                                                                                                nil))
                                                                                                                                                                              nil))
                                                                                                                                                                            nil))
                                                                                                                                                                          nil))
                                                                                                                                                                        nil))
                                                                                                                                                                      nil))
                                                                                                                                                                    nil))
                                                                                                                                                                  nil))
                                                                                                                                                                nil))
                                                                                                                                                              nil)
                                                                                                                                                             ("2"
                                                                                                                                                              (expand
                                                                                                                                                               "polynomial"
                                                                                                                                                               1
                                                                                                                                                               2)
                                                                                                                                                              (("2"
                                                                                                                                                                (lemma
                                                                                                                                                                 "sigma_split")
                                                                                                                                                                (("2"
                                                                                                                                                                  (inst?)
                                                                                                                                                                  (("2"
                                                                                                                                                                    (inst
                                                                                                                                                                     -
                                                                                                                                                                     "q!2")
                                                                                                                                                                    (("2"
                                                                                                                                                                      (assert)
                                                                                                                                                                      (("2"
                                                                                                                                                                        (replaces
                                                                                                                                                                         -1)
                                                                                                                                                                        (("2"
                                                                                                                                                                          (invoke
                                                                                                                                                                           (case
                                                                                                                                                                            "%1 = 0")
                                                                                                                                                                           (!
                                                                                                                                                                            1
                                                                                                                                                                            2
                                                                                                                                                                            2))
                                                                                                                                                                          (("1"
                                                                                                                                                                            (replaces
                                                                                                                                                                             -1)
                                                                                                                                                                            (("1"
                                                                                                                                                                              (assert)
                                                                                                                                                                              (("1"
                                                                                                                                                                                (expand
                                                                                                                                                                                 "polynomial"
                                                                                                                                                                                 1)
                                                                                                                                                                                (("1"
                                                                                                                                                                                  (rewrite
                                                                                                                                                                                   "sigma_eq")
                                                                                                                                                                                  (("1"
                                                                                                                                                                                    (skosimp*)
                                                                                                                                                                                    (("1"
                                                                                                                                                                                      (expand
                                                                                                                                                                                       "G2"
                                                                                                                                                                                       1)
                                                                                                                                                                                      (("1"
                                                                                                                                                                                        (propax)
                                                                                                                                                                                        nil
                                                                                                                                                                                        nil))
                                                                                                                                                                                      nil))
                                                                                                                                                                                    nil))
                                                                                                                                                                                  nil))
                                                                                                                                                                                nil))
                                                                                                                                                                              nil))
                                                                                                                                                                            nil)
                                                                                                                                                                           ("2"
                                                                                                                                                                            (rewrite
                                                                                                                                                                             "sigma_restrict_eq_0")
                                                                                                                                                                            (("2"
                                                                                                                                                                              (skosimp*)
                                                                                                                                                                              (("2"
                                                                                                                                                                                (expand
                                                                                                                                                                                 "G2"
                                                                                                                                                                                 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))
                                                                                                                            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"
                                                                          (copy
                                                                           "css")
                                                                          (("2"
                                                                            (expand
                                                                             "constructed_sturm_sequence?"
                                                                             -1)
                                                                            (("2"
                                                                              (flatten)
                                                                              (("2"
                                                                                (inst
                                                                                 -
                                                                                 "i")
                                                                                (("2"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("3"
                                                                          (copy
                                                                           "css")
                                                                          (("3"
                                                                            (expand
                                                                             "constructed_sturm_sequence?"
                                                                             -1)
                                                                            (("3"
                                                                              (flatten)
                                                                              (("3"
                                                                                (inst
                                                                                 -
                                                                                 "i-1"
                                                                                 "i")
                                                                                (("3"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (flatten)
                                                        (("2"
                                                          (case
                                                           "EXISTS (x): polynomial(p(1 + i), n(1 + i))(x)/=0")
                                                          (("1"
                                                            (skeep)
                                                            (("1"
                                                              (inst
                                                               +
                                                               "x")
                                                              (("1"
                                                                (flatten)
                                                                (("1"
                                                                  (lemma
                                                                   "scal_polynomial2")
                                                                  (("1"
                                                                    (inst
                                                                     -
                                                                     _
                                                                     "-c"
                                                                     _
                                                                     _)
                                                                    (("1"
                                                                      (inst
                                                                       -
                                                                       "pd`rem"
                                                                       "pd`rdeg"
                                                                       "x")
                                                                      (("1"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (hide
                                                             (2 3))
                                                            (("2"
                                                              (lemma
                                                               "polynomial_eq_coeff")
                                                              (("2"
                                                                (inst
                                                                 -
                                                                 "p(1+i)"
                                                                 "LAMBDA (i:nat): 0"
                                                                 "n(1+i)")
                                                                (("2"
                                                                  (flatten)
                                                                  (("2"
                                                                    (hide
                                                                     -2)
                                                                    (("2"
                                                                      (split
                                                                       -)
                                                                      (("1"
                                                                        (inst
                                                                         -
                                                                         "n(1+i)")
                                                                        (("1"
                                                                          (copy
                                                                           "css")
                                                                          (("1"
                                                                            (expand
                                                                             "constructed_sturm_sequence?"
                                                                             -1)
                                                                            (("1"
                                                                              (flatten)
                                                                              (("1"
                                                                                (inst
                                                                                 -
                                                                                 "1+i")
                                                                                (("1"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (decompose-equality
                                                                         1)
                                                                        (("2"
                                                                          (inst
                                                                           +
                                                                           "x!1")
                                                                          (("2"
                                                                            (flatten)
                                                                            (("2"
                                                                              (replaces
                                                                               -1)
                                                                              (("2"
                                                                                (expand
                                                                                 "polynomial"
                                                                                 1)
                                                                                (("2"
                                                                                  (rewrite
                                                                                   "sigma_restrict_eq_0"
                                                                                   1)
                                                                                  (("2"
                                                                                    (skosimp*)
                                                                                    (("2"
                                                                                      (lift-if)
                                                                                      (("2"
                                                                                        (ground)
                                                                                        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))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (DivType type-eq-decl nil polynomial_division nil)
    (poly_divide def-decl "DivType" polynomial_division nil)
    (polynomial_degree_existence formula-decl nil more_polynomial_props
     "reals/")
    (max_linear_div_power_scal formula-decl nil more_polynomial_props
     "reals/")
    (sigma_split formula-decl nil sigma "reals/")
    (subrange type-eq-decl nil integers nil)
    (sigma_restrict_eq_0 formula-decl nil sigma "reals/")
    (real_plus_real_is_real application-judgement "real" reals nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (T_low type-eq-decl nil sigma "reals/")
    (T_high type-eq-decl nil sigma "reals/")
    (sigma def-decl "real" sigma "reals/")
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (^ const-decl "real" exponentiation nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (below type-eq-decl nil naturalnumbers nil)
    (max_linear_div_power_rew2 formula-decl nil more_polynomial_props
     "reals/")
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (poly_divide_lengths formula-decl nil polynomial_division nil)
    (* const-decl "[T -> real]" real_fun_ops "reals/")
    (polynomial const-decl "[real -> real]" polynomials "reals/")
    (nzreal nonempty-type-eq-decl nil reals nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (poly_divide_def formula-decl nil polynomial_division nil)
    (polynomial_prod const-decl "real" polynomials "reals/")
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (G2 skolem-const-decl "[nat -> real]" sturm nil)
    (polynomial_prod_def formula-decl nil polynomials "reals/")
    (sigma_eq formula-decl nil sigma "reals/")
    (G1 skolem-const-decl "[nat -> real]" sturm nil)
    (polynomial_sub formula-decl nil polynomials "reals/")
    (expt def-decl "real" exponentiation nil)
    (- const-decl "[T -> real]" real_fun_ops "reals/")
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (div_linear_power_reduces formula-decl nil more_polynomial_props
     "reals/")
    (int_plus_int_is_int application-judgement "int" integers nil)
    (max_linear_div_power_additive formula-decl nil
     more_polynomial_props "reals/")
    (poly_max_zero_power formula-decl nil more_polynomial_props
     "reals/")
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (polynomial_eq_coeff formula-decl nil polynomials "reals/")
    (real_minus_real_is_real application-judgement "real" reals nil)
    (minus_nzreal_is_nzreal application-judgement "nzreal" real_types
     nil)
    (scal_polynomial2 formula-decl nil polynomials "reals/")
    (max_linear_div_power_derivative formula-decl nil
     more_polynomial_props "reals/")
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (i skolem-const-decl "nat" sturm nil)
    (u skolem-const-decl "upto(1 + i)" sturm nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (/= const-decl "boolean" notequal nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_gt_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)
    (nat_induction formula-decl nil naturalnumbers nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (<= const-decl "bool" reals nil) (< const-decl "bool" reals nil)
    (max_linear_div_power? const-decl "bool" more_polynomial_props
     "reals/")
    (sequence type-eq-decl nil sequences nil)
    (constructed_sturm_sequence? const-decl "bool" sturm nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (int_minus_int_is_int application-judgement "int" integers nil))
   shostak))
 (constructed_sturm_seq_repeated_root_struct_TCC1 0
  (constructed_sturm_seq_repeated_root_struct_TCC1-1 nil 3591976316
   ("" (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)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (/= const-decl "boolean" notequal nil)
    (constructed_sturm_sequence? const-decl "bool" sturm nil)
    (^ const-decl "real" exponentiation nil)
    (polynomial const-decl "[real -> real]" polynomials "reals/")
    (poly_deriv const-decl "real" polynomials "reals/")
    (max_linear_div_power? const-decl "bool" more_polynomial_props
     "reals/")
    (real_times_real_is_real application-judgement "real" reals nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_plus_real_is_real application-judgement "real" reals nil))
   nil))
 (constructed_sturm_seq_repeated_root_struct_TCC2 0
  (constructed_sturm_seq_repeated_root_struct_TCC2-1 nil 3591976316
   ("" (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)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (/= const-decl "boolean" notequal nil)
    (constructed_sturm_sequence? const-decl "bool" sturm nil)
    (^ const-decl "real" exponentiation nil)
    (polynomial const-decl "[real -> real]" polynomials "reals/")
    (poly_deriv const-decl "real" polynomials "reals/")
    (max_linear_div_power? const-decl "bool" more_polynomial_props
     "reals/")
    (real_times_real_is_real application-judgement "real" reals nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil))
   nil))
 (constructed_sturm_seq_repeated_root_struct_TCC3 0
  (constructed_sturm_seq_repeated_root_struct_TCC3-1 nil 3591976316
   ("" (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)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (real_gt_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_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)
    (/= const-decl "boolean" notequal nil)
    (constructed_sturm_sequence? const-decl "bool" sturm nil)
    (^ const-decl "real" exponentiation nil)
    (polynomial const-decl "[real -> real]" polynomials "reals/")
    (poly_deriv const-decl "real" polynomials "reals/")
    (max_linear_div_power? const-decl "bool" more_polynomial_props
     "reals/")
    (real_times_real_is_real application-judgement "real" reals nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_plus_real_is_real application-judgement "real" reals nil))
   nil))
 (constructed_sturm_seq_repeated_root_struct_TCC4 0
  (constructed_sturm_seq_repeated_root_struct_TCC4-1 nil 3591976316
   ("" (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)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (real_gt_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_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)
    (/= const-decl "boolean" notequal nil)
    (constructed_sturm_sequence? const-decl "bool" sturm nil)
    (^ const-decl "real" exponentiation nil)
    (polynomial const-decl "[real -> real]" polynomials "reals/")
    (poly_deriv const-decl "real" polynomials "reals/")
    (max_linear_div_power? const-decl "bool" more_polynomial_props
     "reals/")
    (real_times_real_is_real application-judgement "real" reals nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_plus_real_is_real application-judgement "real" reals nil))
   nil))
 (constructed_sturm_seq_repeated_root_struct 0
  (constructed_sturm_seq_repeated_root_struct-2 nil 3591975639
   ("" (skeep)
    (("" (label "css" -1)
      (("" (skeep)
        (("" (lemma "constructed_sturm_seq_repeated_root")
          (("" (inst?)
            (("" (assert)
              (("" (inst - "y")
                (("" (inst - "i")
                  (("" (assert)
                    (("" (inst-cp - "0")
                      (("" (inst-cp - "1")
                        (("" (label "allzero" -1)
                          (("" (assert)
                            (("" (lemma "poly_max_zero_power")
                              ((""
                                (inst - "p(0)" "n(0)" "y")
                                ((""
                                  (assert)
                                  ((""
                                    (case "p(0)(n(0))/=0")
                                    (("1"
                                      (ground)
                                      (("1"
                                        (skolem -1 "mm")
                                        (("1"
                                          (inst + "mm")
                                          (("1"
                                            (case "NOT mm > 1")
                                            (("1"
                                              (case "NOT mm = 1")
                                              (("1" (assertnil)
                                               ("2"
                                                (hide 1)
                                                (("2"
                                                  (replace -1)
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (expand
                                                       "max_linear_div_power?"
                                                       -2)
                                                      (("2"
                                                        (skeep)
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (expand
                                                             "^"
                                                             -4)
                                                            (("2"
                                                              (expand
                                                               "expt")
                                                              (("2"
                                                                (copy
                                                                 "css")
                                                                (("2"
                                                                  (expand
                                                                   "constructed_sturm_sequence?"
                                                                   -1)
                                                                  (("2"
                                                                    (inst
                                                                     -5
                                                                     "y")
                                                                    (("2"
                                                                      (assert)
                                                                      (("2"
                                                                        (flatten)
                                                                        (("2"
                                                                          (assert)
                                                                          nil)))))))))))))))))))))))))))))
                                             ("2"
                                              (assert)
                                              (("2"
                                                (splash 2)
                                                (("1"
                                                  (inst-cp - "m-2")
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (lemma
                                                       "max_linear_div_power_derivative")
                                                      (("1"
                                                        (inst
                                                         -
                                                         "p(0)"
                                                         "n(0)"
                                                         "y"
                                                         "mm")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (flatten)
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (case
                                                                 "m = 2")
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (replace
                                                                     -1)
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (expand
                                                                         "constructed_sturm_sequence?")
                                                                        (("1"
                                                                          (flatten)
                                                                          (("1"
                                                                            (assert)
                                                                            nil)))))))))))
                                                                 ("2"
                                                                  (assert)
                                                                  (("2"
                                                                    (case
                                                                     "m = 1")
                                                                    (("1"
                                                                      (expand
                                                                       "constructed_sturm_sequence?")
                                                                      (("1"
                                                                        (flatten)
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (replace
                                                                             -1)
                                                                            (("1"
                                                                              (assert)
                                                                              (("1"
                                                                                (replace
                                                                                 -12)
                                                                                (("1"
                                                                                  (expand
                                                                                   "poly_deriv")
                                                                                  (("1"
                                                                                    (assert)
                                                                                    nil)))))))))))))))
                                                                     ("2"
                                                                      (label
                                                                       "PSty"
                                                                       4)
                                                                      (("2"
                                                                        (assert)
                                                                        (("2"
                                                                          (copy
                                                                           "css")
                                                                          (("2"
                                                                            (expand
                                                                             "constructed_sturm_sequence?"
                                                                             -1)
                                                                            (("2"
                                                                              (flatten)
                                                                              (("2"
                                                                                (inst
                                                                                 -7
                                                                                 "m")
                                                                                (("2"
                                                                                  (assert)
                                                                                  (("2"
                                                                                    (skeep)
                                                                                    (("2"
                                                                                      (case
                                                                                       "NOT polynomial(p(m),n(m)) = (LAMBDA (xy:real): 0)")
                                                                                      (("1"
                                                                                        (decompose-equality
                                                                                         1)
                                                                                        (("1"
                                                                                          (replace
                                                                                           -5
                                                                                           1)
                                                                                          (("1"
                                                                                            (expand
                                                                                             "polynomial"
                                                                                             1)
                                                                                            (("1"
                                                                                              (expand
                                                                                               "sigma")
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "sigma")
                                                                                                (("1"
                                                                                                  (propax)
                                                                                                  nil)))))))))))
                                                                                       ("2"
                                                                                        (replace
                                                                                         -1)
                                                                                        (("2"
                                                                                          (name
                                                                                           "PD"
                                                                                           "poly_divide(p(m - 2), n(m - 2))(p(m - 1), n(m - 1))
                                                                                                                                       (0)")
                                                                                          (("2"
                                                                                            (replace
                                                                                             -1)
                                                                                            (("2"
                                                                                              (case
                                                                                               "polynomial(PD`rem,PD`rdeg) = (LAMBDA (xy:real): 0)")
                                                                                              (("1"
                                                                                                (lemma
                                                                                                 "constructed_sturm_seq_repeated_root_mth")
                                                                                                (("1"
                                                                                                  (inst
                                                                                                   -
                                                                                                   "m-1"
                                                                                                   "m"
                                                                                                   "n"
                                                                                                   "p"
                                                                                                   "y"
                                                                                                   "mm")
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    (("1"
                                                                                                      (inst
                                                                                                       -
                                                                                                       "m-1")
                                                                                                      (("1"
                                                                                                        (skeep)
                                                                                                        (("1"
                                                                                                          (lemma
                                                                                                           "poly_divide_def")
                                                                                                          (("1"
                                                                                                            (inst
                                                                                                             -
                                                                                                             "p(m-2)"
                                                                                                             "p(m-1)"
                                                                                                             "0"
                                                                                                             "n(m-1)"
                                                                                                             "n(m-2)")
                                                                                                            (("1"
                                                                                                              (replace
                                                                                                               -5)
                                                                                                              (("1"
                                                                                                                (assert)
                                                                                                                (("1"
                                                                                                                  (split
                                                                                                                   -)
                                                                                                                  (("1"
                                                                                                                    (replace
                                                                                                                     -4)
                                                                                                                    (("1"
                                                                                                                      (assert)
                                                                                                                      (("1"
                                                                                                                        (rewrite
                                                                                                                         "max_linear_div_power_rew"
                                                                                                                         -3)
                                                                                                                        (("1"
                                                                                                                          (flatten)
                                                                                                                          (("1"
                                                                                                                            (skolem
                                                                                                                             -
                                                                                                                             "bm1")
                                                                                                                            (("1"
                                                                                                                              (flatten)
                                                                                                                              (("1"
                                                                                                                                (case
                                                                                                                                 "NOT polynomial(p(m-1),n(m-1)) = (LAMBDA (x): (x - y) ^ kp * polynomial(bm1, n(m - 1) - kp)(x))")
                                                                                                                                (("1"
                                                                                                                                  (decompose-equality)
                                                                                                                                  nil)
                                                                                                                                 ("2"
                                                                                                                                  (hide
                                                                                                                                   -5)
                                                                                                                                  (("2"
                                                                                                                                    (replace
                                                                                                                                     -1
                                                                                                                                     -2)
                                                                                                                                    (("2"
                                                                                                                                      (assert)
                                                                                                                                      (("2"
                                                                                                                                        (case
                                                                                                                                         "EXISTS (aa:[nat->real],nm:nat): FORALL (x:real): polynomial(p(m-2),n(m-2))(x) = (x-y)^kp*polynomial(aa,nm)(x)")
                                                                                                                                        (("1"
                                                                                                                                          (skeep)
                                                                                                                                          (("1"
                                                                                                                                            (case
                                                                                                                                             "NOT kp = mm-1")
                                                                                                                                            (("1"
                                                                                                                                              (lemma
                                                                                                                                               "max_linear_div_power_lower_bound")
                                                                                                                                              (("1"
                                                                                                                                                (inst
                                                                                                                                                 -
                                                                                                                                                 "p(m-2)"
                                                                                                                                                 "n(m-2)"
                                                                                                                                                 "y"
                                                                                                                                                 "aa"
                                                                                                                                                 "kp"
                                                                                                                                                 "nm"
                                                                                                                                                 "mm-1")
                                                                                                                                                (("1"
                                                                                                                                                  (assert)
                                                                                                                                                  nil)))))
                                                                                                                                             ("2"
                                                                                                                                              (rewrite
                                                                                                                                               "max_linear_div_power_rew2"
                                                                                                                                               +)
                                                                                                                                              (("2"
                                                                                                                                                (inst
                                                                                                                                                 +
                                                                                                                                                 "bm1"
                                                                                                                                                 "n(m-1)-kp")
                                                                                                                                                (("2"
                                                                                                                                                  (assert)
                                                                                                                                                  nil)))))))))
                                                                                                                                         ("2"
                                                                                                                                          (inst
                                                                                                                                           +
                                                                                                                                           "polynomial_prod(PD`quot,PD`qdeg,bm1,n(m-1)-kp)"
                                                                                                                                           "PD`qdeg+n(m-1)-kp")
                                                                                                                                          (("1"
                                                                                                                                            (skeep)
                                                                                                                                            (("1"
                                                                                                                                              (inst
                                                                                                                                               -
                                                                                                                                               "x")
                                                                                                                                              (("1"
                                                                                                                                                (replace
                                                                                                                                                 -2
                                                                                                                                                 +)
                                                                                                                                                (("1"
                                                                                                                                                  (lemma
                                                                                                                                                   "polynomial_prod_def")
                                                                                                                                                  (("1"
                                                                                                                                                    (inst?)
                                                                                                                                                    (("1"
                                                                                                                                                      (assert)
                                                                                                                                                      nil)))))))))))
                                                                                                                                           ("2"
                                                                                                                                            (assert)
                                                                                                                                            nil)))))))))))
                                                                                                                                 ("3"
                                                                                                                                  (assert)
                                                                                                                                  nil)))))))))))))))
                                                                                                                   ("2"
                                                                                                                    (copy
                                                                                                                     "css")
                                                                                                                    (("2"
                                                                                                                      (expand
                                                                                                                       "constructed_sturm_sequence?"
                                                                                                                       -1)
                                                                                                                      (("2"
                                                                                                                        (flatten)
                                                                                                                        (("2"
                                                                                                                          (inst?)
                                                                                                                          (("2"
                                                                                                                            (assert)
                                                                                                                            nil)))))))))
                                                                                                                   ("3"
                                                                                                                    (assert)
                                                                                                                    (("3"
                                                                                                                      (copy
                                                                                                                       "css")
                                                                                                                      (("3"
                                                                                                                        (expand
                                                                                                                         "constructed_sturm_sequence?"
                                                                                                                         -1)
                                                                                                                        (("3"
                                                                                                                          (flatten)
                                                                                                                          (("3"
                                                                                                                            (inst
                                                                                                                             -2
                                                                                                                             "m-2"
                                                                                                                             "m-1")
                                                                                                                            (("3"
                                                                                                                              (assert)
                                                                                                                              nil)))))))))))))))))))))))))))))))
                                                                                               ("2"
                                                                                                (hide-all-but
                                                                                                 (-9
                                                                                                  1))
                                                                                                (("2"
                                                                                                  (decompose-equality)
                                                                                                  (("2"
                                                                                                    (decompose-equality
                                                                                                     -)
                                                                                                    (("2"
                                                                                                      (inst
                                                                                                       -
                                                                                                       "x!1")
                                                                                                      (("2"
                                                                                                        (mult-by
                                                                                                         1
                                                                                                         "-c")
                                                                                                        (("2"
                                                                                                          (rewrite
                                                                                                           "scal_polynomial2")
                                                                                                          (("2"
                                                                                                            (assert)
                                                                                                            nil)))))))))))))))))))))))))))))))))))))))))))))))))))))))))
                                                   ("2"
                                                    (assert)
                                                    (("2"
                                                      (case "m = 1")
                                                      (("1"
                                                        (copy "css")
                                                        (("1"
                                                          (expand
                                                           "constructed_sturm_sequence?"
                                                           -1
                                                           :assert?
                                                           none)
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (replace
                                                               -2)
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (flatten)
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (copy
                                                                       -8)
                                                                      (("1"
                                                                        (expand
                                                                         "max_linear_div_power?"
                                                                         -1)
                                                                        (("1"
                                                                          (propax)
                                                                          nil)))))))))))))))))))
                                                       ("2"
                                                        (assert)
                                                        nil)))))))
                                                 ("2"
                                                  (induct "j")
                                                  (("1" (assertnil)
                                                   ("2"
                                                    (skolem 1 "j")
                                                    (("2"
                                                      (flatten)
                                                      (("2"
                                                        (assert)
                                                        (("2"
                                                          (case
                                                           "j = 0")
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (replaces
                                                               -1)
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (rewrite
                                                                   "max_linear_div_power_rew2"
                                                                   1)
                                                                  (("1"
                                                                    (expand
                                                                     "max_linear_div_power?"
                                                                     -4)
                                                                    (("1"
                                                                      (skosimp*)
                                                                      (("1"
                                                                        (inst
                                                                         +
                                                                         "q!1"
                                                                         "n(0)-mm")
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (copy
                                                                             "css")
                                                                            (("1"
                                                                              (expand
                                                                               "constructed_sturm_sequence?"
                                                                               -1
                                                                               :assert?
                                                                               none)
                                                                              (("1"
                                                                                (flatten)
                                                                                (("1"
                                                                                  (assert)
                                                                                  nil)))))))))
                                                                         ("2"
                                                                          (assert)
                                                                          nil)))))))))))))))
                                                           ("2"
                                                            (assert)
                                                            (("2"
                                                              (lemma
                                                               "constructed_sturm_seq_repeated_root_mth")
                                                              (("2"
                                                                (inst?)
                                                                (("2"
                                                                  (inst
                                                                   -
                                                                   "m-1"
                                                                   "m")
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (label
                                                                       "mldpj"
                                                                       -2)
                                                                      (("2"
                                                                        (inst-cp
                                                                         -
                                                                         "1+j")
                                                                        (("2"
                                                                          (assert)
                                                                          (("2"
                                                                            (skeep)
                                                                            (("2"
                                                                              (case
                                                                               "NOT kp > mm-1")
                                                                              (("1"
                                                                                (assert)
                                                                                nil)
                                                                               ("2"
                                                                                (hide
                                                                                 -3)
                                                                                (("2"
                                                                                  (assert)
                                                                                  (("2"
                                                                                    (label
                                                                                     "mldpkp"
                                                                                     -3)
                                                                                    (("2"
                                                                                      (copy
                                                                                       "css")
                                                                                      (("2"
                                                                                        (label
                                                                                         "cspz"
                                                                                         -1)
                                                                                        (("2"
                                                                                          (expand
                                                                                           "constructed_sturm_sequence?"
                                                                                           "cspz")
                                                                                          (("2"
                                                                                            (flatten)
                                                                                            (("2"
                                                                                              (label
                                                                                               "igzy"
                                                                                               -7)
                                                                                              (("2"
                                                                                                (hide
                                                                                                 "cspz")
                                                                                                (("2"
                                                                                                  (inst
                                                                                                   -
                                                                                                   "2+j")
                                                                                                  (("2"
                                                                                                    (assert)
                                                                                                    (("2"
                                                                                                      (skeep)
                                                                                                      (("2"
                                                                                                        (name
                                                                                                         "PD"
                                                                                                         "poly_divide(p(j), n(j))(p(1 + j), n(1 + j))(0)")
                                                                                                        (("2"
                                                                                                          (replace
                                                                                                           -1)
                                                                                                          (("2"
                                                                                                            (case
                                                                                                             "max_linear_div_power?(PD`rem,PD`rdeg,y)(mm-1)")
                                                                                                            (("1"
                                                                                                              (case
                                                                                                               "max_linear_div_power?(-c*PD`rem,PD`rdeg,y)(mm-1)")
                                                                                                              (("1"
                                                                                                                (rewrite
                                                                                                                 "max_linear_div_power_rew2"
                                                                                                                 3)
                                                                                                                (("1"
                                                                                                                  (rewrite
                                                                                                                   "max_linear_div_power_rew2"
                                                                                                                   -1)
                                                                                                                  (("1"
                                                                                                                    (assert)
                                                                                                                    (("1"
                                                                                                                      (replace
                                                                                                                       "igzy"
                                                                                                                       :dir
                                                                                                                       rl)
                                                                                                                      (("1"
                                                                                                                        (propax)
                                                                                                                        nil)))))))))
                                                                                                               ("2"
                                                                                                                (hide-all-but
                                                                                                                 (-1
                                                                                                                  1))
                                                                                                                (("2"
                                                                                                                  (rewrite
                                                                                                                   "max_linear_div_power_scal"
                                                                                                                   :dir
                                                                                                                   rl)
                                                                                                                  nil)))))
                                                                                                             ("2"
                                                                                                              (hide
                                                                                                               (3
                                                                                                                4))
                                                                                                              (("2"
                                                                                                                (lemma
                                                                                                                 "poly_divide_def")
                                                                                                                (("2"
                                                                                                                  (inst?)
                                                                                                                  (("2"
                                                                                                                    (assert)
                                                                                                                    (("2"
                                                                                                                      (replace
                                                                                                                       -2)
                                                                                                                      (("2"
                                                                                                                        (split
                                                                                                                         -)
                                                                                                                        (("1"
                                                                                                                          (copy
                                                                                                                           "mldpj")
                                                                                                                          (("1"
                                                                                                                            (rewrite
                                                                                                                             "max_linear_div_power_rew"
                                                                                                                             -1)
                                                                                                                            (("1"
                                                                                                                              (assert)
                                                                                                                              (("1"
                                                                                                                                (flatten)
                                                                                                                                (("1"
                                                                                                                                  (skolem
                                                                                                                                   -
                                                                                                                                   "bb")
                                                                                                                                  (("1"
                                                                                                                                    (flatten)
                                                                                                                                    (("1"
                                                                                                                                      (copy
                                                                                                                                       "mldpkp")
                                                                                                                                      (("1"
                                                                                                                                        (rewrite
                                                                                                                                         "max_linear_div_power_rew"
                                                                                                                                         -1)
                                                                                                                                        (("1"
                                                                                                                                          (flatten)
                                                                                                                                          (("1"
                                                                                                                                            (assert)
                                                                                                                                            (("1"
                                                                                                                                              (skolem
                                                                                                                                               -
                                                                                                                                               "cc")
                                                                                                                                              (("1"
                                                                                                                                                (flatten)
                                                                                                                                                (("1"
                                                                                                                                                  (lemma
                                                                                                                                                   "linear_power_is_differentiable")
                                                                                                                                                  (("1"
                                                                                                                                                    (inst
                                                                                                                                                     -
                                                                                                                                                     "kp-mm+1"
                                                                                                                                                     "y")
                                                                                                                                                    (("1"
                                                                                                                                                      (assert)
                                                                                                                                                      (("1"
                                                                                                                                                        (skeep)
                                                                                                                                                        (("1"
                                                                                                                                                          (name
                                                                                                                                                           "A1"
                                                                                                                                                           "polynomial_prod(a,1-mm+kp,cc,n(1+j)-kp)")
                                                                                                                                                          (("1"
                                                                                                                                                            (case
                                                                                                                                                             "NOT polynomial(p(1 + j), n(1 + j)) = (LAMBDA (x): (x-y)^(mm-1)*polynomial(polynomial_prod(a, 1 - mm + kp, cc, n(1 + j) - kp),n(1+j)-mm+1)(x))")
                                                                                                                                                            (("1"
                                                                                                                                                              (decompose-equality
                                                                                                                                                               +)
                                                                                                                                                              (("1"
                                                                                                                                                                (rewrite
                                                                                                                                                                 "polynomial_prod_def"
                                                                                                                                                                 1
                                                                                                                                                                 :dir
                                                                                                                                                                 rl)
                                                                                                                                                                (("1"
                                                                                                                                                                  (inst
                                                                                                                                                                   -4
                                                                                                                                                                   "x!1")
                                                                                                                                                                  (("1"
                                                                                                                                                                    (replace
                                                                                                                                                                     -4
                                                                                                                                                                     +)
                                                                                                                                                                    (("1"
                                                                                                                                                                      (inst
                                                                                                                                                                       -7
                                                                                                                                                                       "x!1")
                                                                                                                                                                      (("1"
                                                                                                                                                                        (lemma
                                                                                                                                                                         "expt_plus")
                                                                                                                                                                        (("1"
                                                                                                                                                                          (inst
                                                                                                                                                                           -
                                                                                                                                                                           "mm-1"
                                                                                                                                                                           "kp-mm+1"
                                                                                                                                                                           "x!1-y")
                                                                                                                                                                          (("1"
                                                                                                                                                                            (assert)
                                                                                                                                                                            nil)
                                                                                                                                                                           ("2"
                                                                                                                                                                            (flatten)
                                                                                                                                                                            (("2"
                                                                                                                                                                              (case
                                                                                                                                                                               "x!1 = y")
                                                                                                                                                                              (("1"
                                                                                                                                                                                (replaces
                                                                                                                                                                                 -1)
                                                                                                                                                                                (("1"
                                                                                                                                                                                  (assert)
                                                                                                                                                                                  (("1"
                                                                                                                                                                                    (expand
                                                                                                                                                                                     "^"
                                                                                                                                                                                     1)
                                                                                                                                                                                    (("1"
                                                                                                                                                                                      (expand
                                                                                                                                                                                       "expt"
                                                                                                                                                                                       1)
                                                                                                                                                                                      (("1"
                                                                                                                                                                                        (inst
                                                                                                                                                                                         "allzero"
                                                                                                                                                                                         "1+j")
                                                                                                                                                                                        nil)))))))))
                                                                                                                                                                               ("2"
                                                                                                                                                                                (assert)
                                                                                                                                                                                nil)))))))))))))))))))
                                                                                                                                                             ("2"
                                                                                                                                                              (replace
                                                                                                                                                               -2)
                                                                                                                                                              (("2"
                                                                                                                                                                (assert)
                                                                                                                                                                (("2"
                                                                                                                                                                  (replace
                                                                                                                                                                   -1)
                                                                                                                                                                  (("2"
                                                                                                                                                                    (assert)
                                                                                                                                                                    (("2"
                                                                                                                                                                      (case
                                                                                                                                                                       "NOT polynomial(A1,1+n(1+j)-mm)(y)=0")
                                                                                                                                                                      (("1"
                                                                                                                                                                        (expand
                                                                                                                                                                         "A1"
                                                                                                                                                                         1)
                                                                                                                                                                        (("1"
                                                                                                                                                                          (rewrite
                                                                                                                                                                           "polynomial_prod_def"
                                                                                                                                                                           1
                                                                                                                                                                           :dir
                                                                                                                                                                           rl)
                                                                                                                                                                          (("1"
                                                                                                                                                                            (inst
                                                                                                                                                                             -5
                                                                                                                                                                             "y")
                                                                                                                                                                            (("1"
                                                                                                                                                                              (replace
                                                                                                                                                                               -5
                                                                                                                                                                               +)
                                                                                                                                                                              (("1"
                                                                                                                                                                                (assert)
                                                                                                                                                                                (("1"
                                                                                                                                                                                  (expand
                                                                                                                                                                                   "^"
                                                                                                                                                                                   1)
                                                                                                                                                                                  (("1"
                                                                                                                                                                                    (expand
                                                                                                                                                                                     "expt"
                                                                                                                                                                                     1)
                                                                                                                                                                                    (("1"
                                                                                                                                                                                      (propax)
                                                                                                                                                                                      nil)))))))))))))))
                                                                                                                                                                       ("2"
                                                                                                                                                                        (assert)
                                                                                                                                                                        (("2"
                                                                                                                                                                          (name
                                                                                                                                                                           "DV"
                                                                                                                                                                           "polynomial_prod(PD`quot,PD`qdeg,A1,1+n(1+j)-mm)")
                                                                                                                                                                          (("2"
                                                                                                                                                                            (case
                                                                                                                                                                             "NOT polynomial(PD`rem,PD`rdeg) = (LAMBDA (x): (x-y)^(mm-1)*(polynomial(bb,1+n(j)-mm)(x) - polynomial(DV,PD`qdeg+1+n(1+j)-mm)(x)))")
                                                                                                                                                                            (("1"
                                                                                                                                                                              (decompose-equality
                                                                                                                                                                               1)
                                                                                                                                                                              (("1"
                                                                                                                                                                                (expand
                                                                                                                                                                                 "DV")
                                                                                                                                                                                (("1"
                                                                                                                                                                                  (rewrite
                                                                                                                                                                                   "polynomial_prod_def"
                                                                                                                                                                                   1
                                                                                                                                                                                   :dir
                                                                                                                                                                                   rl)
                                                                                                                                                                                  (("1"
                                                                                                                                                                                    (assert)
                                                                                                                                                                                    (("1"
                                                                                                                                                                                      (inst
                                                                                                                                                                                       -11
                                                                                                                                                                                       "x!1")
                                                                                                                                                                                      (("1"
                                                                                                                                                                                        (assert)
                                                                                                                                                                                        (("1"
                                                                                                                                                                                          (replace
                                                                                                                                                                                           -11
                                                                                                                                                                                           :dir
                                                                                                                                                                                           rl)
                                                                                                                                                                                          (("1"
                                                                                                                                                                                            (inst
                                                                                                                                                                                             -12
                                                                                                                                                                                             "x!1")
                                                                                                                                                                                            (("1"
                                                                                                                                                                                              (assert)
                                                                                                                                                                                              nil)))))))))))))))))
                                                                                                                                                                             ("2"
                                                                                                                                                                              (case
                                                                                                                                                                               "EXISTS (RD:[nat->real],RK:nat): FORALL (x): (polynomial(bb, 1 + n(j) - mm)(x) -
                                          polynomial(DV, PD`qdeg + 1 + n(1 + j) - mm)(x)) = polynomial(RD,RK)(x)")
                                                                                                                                                                              (("1"
                                                                                                                                                                                (skeep)
                                                                                                                                                                                (("1"
                                                                                                                                                                                  (rewrite
                                                                                                                                                                                   "max_linear_div_power_rew2"
                                                                                                                                                                                   +)
                                                                                                                                                                                  (("1"
                                                                                                                                                                                    (inst
                                                                                                                                                                                     +
                                                                                                                                                                                     "RD"
                                                                                                                                                                                     "RK")
                                                                                                                                                                                    (("1"
                                                                                                                                                                                      (assert)
                                                                                                                                                                                      (("1"
                                                                                                                                                                                        (split
                                                                                                                                                                                         +)
                                                                                                                                                                                        (("1"
                                                                                                                                                                                          (skeep)
                                                                                                                                                                                          (("1"
                                                                                                                                                                                            (inst
                                                                                                                                                                                             -
                                                                                                                                                                                             "x")
                                                                                                                                                                                            (("1"
                                                                                                                                                                                              (decompose-equality
                                                                                                                                                                                               -2)
                                                                                                                                                                                              (("1"
                                                                                                                                                                                                (inst
                                                                                                                                                                                                 -
                                                                                                                                                                                                 "x")
                                                                                                                                                                                                (("1"
                                                                                                                                                                                                  (assert)
                                                                                                                                                                                                  nil)))))))))
                                                                                                                                                                                         ("2"
                                                                                                                                                                                          (inst
                                                                                                                                                                                           -
                                                                                                                                                                                           "y")
                                                                                                                                                                                          (("2"
                                                                                                                                                                                            (flatten)
                                                                                                                                                                                            (("2"
                                                                                                                                                                                              (replaces
                                                                                                                                                                                               -1)
                                                                                                                                                                                              (("2"
                                                                                                                                                                                                (assert)
                                                                                                                                                                                                (("2"
                                                                                                                                                                                                  (invoke
                                                                                                                                                                                                   (case
                                                                                                                                                                                                    "%1 = 0")
                                                                                                                                                                                                   (!
                                                                                                                                                                                                    -1
                                                                                                                                                                                                    1
                                                                                                                                                                                                    2))
                                                                                                                                                                                                  (("1"
                                                                                                                                                                                                    (assert)
                                                                                                                                                                                                    nil)
                                                                                                                                                                                                   ("2"
                                                                                                                                                                                                    (hide
                                                                                                                                                                                                     -1)
                                                                                                                                                                                                    (("2"
                                                                                                                                                                                                      (expand
                                                                                                                                                                                                       "DV"
                                                                                                                                                                                                       1)
                                                                                                                                                                                                      (("2"
                                                                                                                                                                                                        (rewrite
                                                                                                                                                                                                         "polynomial_prod_def"
                                                                                                                                                                                                         1
                                                                                                                                                                                                         :dir
                                                                                                                                                                                                         rl)
                                                                                                                                                                                                        (("2"
                                                                                                                                                                                                          (invoke
                                                                                                                                                                                                           (case
                                                                                                                                                                                                            "%1 = 0")
                                                                                                                                                                                                           (!
                                                                                                                                                                                                            1
                                                                                                                                                                                                            1
                                                                                                                                                                                                            2))
                                                                                                                                                                                                          (("2"
                                                                                                                                                                                                            (assert)
                                                                                                                                                                                                            nil)))))))))))))))))))))))))))))
                                                                                                                                                                               ("2"
                                                                                                                                                                                (name
                                                                                                                                                                                 "K1"
                                                                                                                                                                                 "1+n(j)-mm")
                                                                                                                                                                                (("2"
                                                                                                                                                                                  (replace
                                                                                                                                                                                   -1)
                                                                                                                                                                                  (("2"
                                                                                                                                                                                    (name
                                                                                                                                                                                     "K2"
                                                                                                                                                                                     "PD`qdeg+1+n(1+j)-mm")
                                                                                                                                                                                    (("2"
                                                                                                                                                                                      (replace
                                                                                                                                                                                       -1)
                                                                                                                                                                                      (("2"
                                                                                                                                                                                        (case
                                                                                                                                                                                         "NOT (K1>=0 AND K2>=0)")
                                                                                                                                                                                        (("1"
                                                                                                                                                                                          (ground)
                                                                                                                                                                                          nil)
                                                                                                                                                                                         ("2"
                                                                                                                                                                                          (hide-all-but
                                                                                                                                                                                           (-1
                                                                                                                                                                                            1))
                                                                                                                                                                                          (("2"
                                                                                                                                                                                            (name
                                                                                                                                                                                             "B1"
                                                                                                                                                                                             "LAMBDA (i:nat): IF i<=K1 THEN bb(i) ELSE 0 ENDIF")
                                                                                                                                                                                            (("2"
                                                                                                                                                                                              (name
                                                                                                                                                                                               "B2"
                                                                                                                                                                                               "LAMBDA (i:nat): IF i<=K2 THEN DV(i) ELSE 0 ENDIF")
                                                                                                                                                                                              (("2"
                                                                                                                                                                                                (inst
                                                                                                                                                                                                 +
                                                                                                                                                                                                 "B1-B2"
                                                                                                                                                                                                 "max(K1,K2)")
                                                                                                                                                                                                (("1"
                                                                                                                                                                                                  (skeep)
                                                                                                                                                                                                  (("1"
                                                                                                                                                                                                    (case
                                                                                                                                                                                                     "polynomial(bb,K1) = polynomial(B1,max(K1,K2))")
                                                                                                                                                                                                    (("1"
                                                                                                                                                                                                      (case
                                                                                                                                                                                                       "polynomial(DV,K2) = polynomial(B2,max(K1,K2))")
                                                                                                                                                                                                      (("1"
                                                                                                                                                                                                        (replace
                                                                                                                                                                                                         -1)
                                                                                                                                                                                                        (("1"
                                                                                                                                                                                                          (replace
                                                                                                                                                                                                           -2)
                                                                                                                                                                                                          (("1"
                                                                                                                                                                                                            (rewrite
                                                                                                                                                                                                             "polynomial_sub")
                                                                                                                                                                                                            (("1"
                                                                                                                                                                                                              (assert)
                                                                                                                                                                                                              (("1"
                                                                                                                                                                                                                (expand
                                                                                                                                                                                                                 "-")
                                                                                                                                                                                                                (("1"
                                                                                                                                                                                                                  (propax)
                                                                                                                                                                                                                  nil)))))))))))
                                                                                                                                                                                                       ("2"
                                                                                                                                                                                                        (hide
                                                                                                                                                                                                         2)
                                                                                                                                                                                                        (("2"
                                                                                                                                                                                                          (decompose-equality
                                                                                                                                                                                                           1)
                                                                                                                                                                                                          (("2"
                                                                                                                                                                                                            (expand
                                                                                                                                                                                                             "polynomial"
                                                                                                                                                                                                             +
                                                                                                                                                                                                             2)
                                                                                                                                                                                                            (("2"
                                                                                                                                                                                                              (lemma
                                                                                                                                                                                                               "sigma_split")
                                                                                                                                                                                                              (("2"
                                                                                                                                                                                                                (inst?)
                                                                                                                                                                                                                (("2"
                                                                                                                                                                                                                  (inst
                                                                                                                                                                                                                   -
                                                                                                                                                                                                                   "K2")
                                                                                                                                                                                                                  (("2"
                                                                                                                                                                                                                    (assert)
                                                                                                                                                                                                                    (("2"
                                                                                                                                                                                                                      (replaces
                                                                                                                                                                                                                       -1)
                                                                                                                                                                                                                      (("2"
                                                                                                                                                                                                                        (invoke
                                                                                                                                                                                                                         (case
                                                                                                                                                                                                                          "%1 = 0")
                                                                                                                                                                                                                         (!
                                                                                                                                                                                                                          1
                                                                                                                                                                                                                          2
                                                                                                                                                                                                                          2))
                                                                                                                                                                                                                        (("1"
                                                                                                                                                                                                                          (replaces
                                                                                                                                                                                                                           -1)
                                                                                                                                                                                                                          (("1"
                                                                                                                                                                                                                            (assert)
                                                                                                                                                                                                                            (("1"
                                                                                                                                                                                                                              (expand
                                                                                                                                                                                                                               "polynomial"
                                                                                                                                                                                                                               +)
                                                                                                                                                                                                                              (("1"
                                                                                                                                                                                                                                (rewrite
                                                                                                                                                                                                                                 "sigma_eq")
                                                                                                                                                                                                                                (("1"
                                                                                                                                                                                                                                  (skosimp*)
                                                                                                                                                                                                                                  (("1"
                                                                                                                                                                                                                                    (expand
                                                                                                                                                                                                                                     "B2"
                                                                                                                                                                                                                                     1)
                                                                                                                                                                                                                                    (("1"
                                                                                                                                                                                                                                      (propax)
                                                                                                                                                                                                                                      nil)))))))))))))
                                                                                                                                                                                                                         ("2"
                                                                                                                                                                                                                          (hide
                                                                                                                                                                                                                           2)
                                                                                                                                                                                                                          (("2"
                                                                                                                                                                                                                            (rewrite
                                                                                                                                                                                                                             "sigma_restrict_eq_0")
                                                                                                                                                                                                                            (("2"
                                                                                                                                                                                                                              (skosimp*)
                                                                                                                                                                                                                              (("2"
                                                                                                                                                                                                                                (expand
                                                                                                                                                                                                                                 "B2"
                                                                                                                                                                                                                                 1)
                                                                                                                                                                                                                                (("2"
                                                                                                                                                                                                                                  (assert)
                                                                                                                                                                                                                                  nil)))))))))))))))))))))))))))
                                                                                                                                                                                                       ("3"
                                                                                                                                                                                                        (propax)
                                                                                                                                                                                                        nil)))
                                                                                                                                                                                                     ("2"
                                                                                                                                                                                                      (hide
                                                                                                                                                                                                       2)
                                                                                                                                                                                                      (("2"
                                                                                                                                                                                                        (decompose-equality
                                                                                                                                                                                                         1)
                                                                                                                                                                                                        (("2"
                                                                                                                                                                                                          (expand
                                                                                                                                                                                                           "polynomial"
                                                                                                                                                                                                           +
                                                                                                                                                                                                           2)
                                                                                                                                                                                                          (("2"
                                                                                                                                                                                                            (lemma
                                                                                                                                                                                                             "sigma_split")
                                                                                                                                                                                                            (("2"
                                                                                                                                                                                                              (inst?)
                                                                                                                                                                                                              (("2"
                                                                                                                                                                                                                (inst
                                                                                                                                                                                                                 -
                                                                                                                                                                                                                 "K1")
                                                                                                                                                                                                                (("2"
                                                                                                                                                                                                                  (assert)
                                                                                                                                                                                                                  (("2"
                                                                                                                                                                                                                    (replaces
                                                                                                                                                                                                                     -1)
                                                                                                                                                                                                                    (("2"
                                                                                                                                                                                                                      (invoke
                                                                                                                                                                                                                       (case
                                                                                                                                                                                                                        "%1 = 0")
                                                                                                                                                                                                                       (!
                                                                                                                                                                                                                        1
                                                                                                                                                                                                                        2
                                                                                                                                                                                                                        2))
                                                                                                                                                                                                                      (("1"
                                                                                                                                                                                                                        (replaces
                                                                                                                                                                                                                         -1)
                                                                                                                                                                                                                        (("1"
                                                                                                                                                                                                                          (assert)
                                                                                                                                                                                                                          (("1"
                                                                                                                                                                                                                            (expand
                                                                                                                                                                                                                             "polynomial"
                                                                                                                                                                                                                             +)
                                                                                                                                                                                                                            (("1"
                                                                                                                                                                                                                              (rewrite
                                                                                                                                                                                                                               "sigma_eq")
                                                                                                                                                                                                                              (("1"
                                                                                                                                                                                                                                (skosimp*)
                                                                                                                                                                                                                                (("1"
                                                                                                                                                                                                                                  (expand
                                                                                                                                                                                                                                   "B1"
                                                                                                                                                                                                                                   1)
                                                                                                                                                                                                                                  (("1"
                                                                                                                                                                                                                                    (propax)
                                                                                                                                                                                                                                    nil)))))))))))))
                                                                                                                                                                                                                       ("2"
                                                                                                                                                                                                                        (hide
                                                                                                                                                                                                                         2)
                                                                                                                                                                                                                        (("2"
                                                                                                                                                                                                                          (rewrite
                                                                                                                                                                                                                           "sigma_restrict_eq_0")
                                                                                                                                                                                                                          (("2"
                                                                                                                                                                                                                            (skosimp*)
                                                                                                                                                                                                                            (("2"
                                                                                                                                                                                                                              (expand
                                                                                                                                                                                                                               "B1"
                                                                                                                                                                                                                               1)
                                                                                                                                                                                                                              (("2"
                                                                                                                                                                                                                                (assert)
                                                                                                                                                                                                                                nil)))))))))))))))))))))))))))
                                                                                                                                                                                                     ("3"
                                                                                                                                                                                                      (assert)
                                                                                                                                                                                                      nil)
                                                                                                                                                                                                     ("4"
                                                                                                                                                                                                      (propax)
                                                                                                                                                                                                      nil)))))
                                                                                                                                                                                                 ("2"
                                                                                                                                                                                                  (assert)
                                                                                                                                                                                                  nil)))))))))))))))))))
                                                                                                                                                                               ("3"
                                                                                                                                                                                (assert)
                                                                                                                                                                                nil)))
                                                                                                                                                                             ("3"
                                                                                                                                                                              (assert)
                                                                                                                                                                              nil)))))))))))))))))))))))))))))))))))))))))))))))))))))
                                                                                                                         ("2"
                                                                                                                          (copy
                                                                                                                           "css")
                                                                                                                          (("2"
                                                                                                                            (expand
                                                                                                                             "constructed_sturm_sequence?"
                                                                                                                             -1)
                                                                                                                            (("2"
                                                                                                                              (flatten)
                                                                                                                              (("2"
                                                                                                                                (inst
                                                                                                                                 -
                                                                                                                                 "1+j")
                                                                                                                                (("2"
                                                                                                                                  (assert)
                                                                                                                                  nil)))))))))
                                                                                                                         ("3"
                                                                                                                          (copy
                                                                                                                           "css")
                                                                                                                          (("3"
                                                                                                                            (expand
                                                                                                                             "constructed_sturm_sequence?"
                                                                                                                             -1)
                                                                                                                            (("3"
                                                                                                                              (flatten)
                                                                                                                              (("3"
                                                                                                                                (inst
                                                                                                                                 -
                                                                                                                                 "j"
                                                                                                                                 "1+j")
                                                                                                                                (("3"
                                                                                                                                  (assert)
                                                                                                                                  nil)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
                                                   ("3"
                                                    (skosimp*)
                                                    (("3"
                                                      (assert)
                                                      nil)))
                                                   ("4"
                                                    (skosimp*)
                                                    (("4"
                                                      (assert)
                                                      nil)))
                                                   ("5"
                                                    (skosimp*)
                                                    (("5"
                                                      (assert)
                                                      nil)))
                                                   ("6"
                                                    (skosimp*)
                                                    (("6"
                                                      (assert)
                                                      nil)))
                                                   ("7"
                                                    (skosimp*)
                                                    (("7"
                                                      (assert)
                                                      nil)))
                                                   ("8"
                                                    (skosimp*)
                                                    (("8"
                                                      (assert)
                                                      nil)))))))))))))))))
                                     ("2"
                                      (copy "css")
                                      (("2"
                                        (expand
                                         "constructed_sturm_sequence?"
                                         -1)
                                        (("2"
                                          (flatten)
                                          (("2"
                                            (inst - "0")
                                            (("2"
                                              (assert)
                                              nil))))))))))))))))))))))))))))))))))))))))))
    nil)
   ((constructed_sturm_seq_repeated_root formula-decl nil sturm nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (<= const-decl "bool" reals nil)
    (poly_max_zero_power formula-decl nil more_polynomial_props
     "reals/")
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (p skolem-const-decl "[nat -> [nat -> real]]" sturm nil)
    (y skolem-const-decl "real" sturm nil)
    (mm skolem-const-decl "posnat" sturm nil)
    (pred type-eq-decl nil defined_types nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (j!1 skolem-const-decl "nat" sturm nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (linear_power_is_differentiable formula-decl nil
     more_polynomial_props "reals/")
    (real_plus_real_is_real application-judgement "real" reals nil)
    (A1 skolem-const-decl "[nat -> real]" sturm nil)
    (odd_minus_even_is_odd application-judgement "odd_int" integers
     nil)
    (B1 skolem-const-decl "[nat -> real]" sturm nil)
    (polynomial_sub formula-decl nil polynomials "reals/")
    (sigma_split formula-decl nil sigma "reals/")
    (sigma_restrict_eq_0 formula-decl nil sigma "reals/")
    (B2 skolem-const-decl "[nat -> real]" sturm nil)
    (sigma_eq formula-decl nil sigma "reals/")
    (T_high type-eq-decl nil sigma "reals/")
    (T_low type-eq-decl nil sigma "reals/")
    (- const-decl "[T -> real]" real_fun_ops "reals/")
    (K2 skolem-const-decl "int" sturm nil)
    (K1 skolem-const-decl "int" sturm nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (int_max application-judgement "{k: int | i <= k AND j <= k}"
     real_defs nil)
    (rat_max application-judgement "{s: rat | s >= q AND s >= r}"
     real_defs nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (PD skolem-const-decl "DivType" sturm nil)
    (j skolem-const-decl "nat" sturm nil)
    (DV skolem-const-decl "[nat -> real]" sturm nil)
    (x!1 skolem-const-decl "real" sturm nil)
    (nat_exp application-judgement "nat" exponentiation nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (expt_plus formula-decl nil exponentiation nil)
    (even_minus_even_is_even application-judgement "even_int" integers
     nil)
    (nzreal nonempty-type-eq-decl nil reals nil)
    (max_linear_div_power_scal formula-decl nil more_polynomial_props
     "reals/")
    (m skolem-const-decl "nat" sturm nil)
    (max_linear_div_power_derivative formula-decl nil
     more_polynomial_props "reals/")
    (polynomial const-decl "[real -> real]" polynomials "reals/")
    (sigma def-decl "real" sigma "reals/")
    (minus_nzreal_is_nzreal application-judgement "nzreal" real_types
     nil)
    (DivType type-eq-decl nil polynomial_division nil)
    (poly_divide def-decl "DivType" polynomial_division nil)
    (poly_divide_def formula-decl nil polynomial_division nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (PD skolem-const-decl "DivType" sturm nil)
    (polynomial_prod const-decl "real" polynomials "reals/")
    (polynomial_prod_def formula-decl nil polynomials "reals/")
    (int_plus_int_is_int application-judgement "int" integers nil)
    (max_linear_div_power_rew2 formula-decl nil more_polynomial_props
     "reals/")
    (max_linear_div_power_lower_bound formula-decl nil
     more_polynomial_props "reals/")
    (kp skolem-const-decl "posnat" sturm nil)
    (n skolem-const-decl "[nat -> nat]" sturm nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (max_linear_div_power_rew formula-decl nil more_polynomial_props
     "reals/")
    (below type-eq-decl nil naturalnumbers nil)
    (constructed_sturm_seq_repeated_root_mth formula-decl nil sturm
     nil)
    (scal_polynomial2 formula-decl nil polynomials "reals/")
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (both_sides_times1 formula-decl nil real_props nil)
    (* const-decl "[T -> real]" real_fun_ops "reals/")
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (< const-decl "bool" reals nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (bijective? const-decl "bool" functions nil)
    (id const-decl "(bijective?[T, T])" identity nil)
    (TRUE const-decl "bool" booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (max_linear_div_power? const-decl "bool" more_polynomial_props
     "reals/")
    (expt def-decl "real" exponentiation nil)
    (constructed_sturm_sequence? const-decl "bool" sturm nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (^ const-decl "real" exponentiation nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (/= const-decl "boolean" notequal nil)
    (sequence type-eq-decl nil sequences nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers 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)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil))
   nil)
  (constructed_sturm_seq_repeated_root_struct-1 nil 3591101713
   ("" (skeep)
    (("" (label "css" -1)
      (("" (skeep)
        (("" (lemma "constructed_sturm_seq_repeated_root")
          (("" (inst?)
            (("" (assert)
              (("" (inst - "y")
                (("" (inst - "i")
                  (("" (assert)
                    (("" (inst-cp - "0")
                      (("" (inst-cp - "1")
                        (("" (assert)
                          (("" (lemma "poly_max_zero_power")
                            (("" (inst - "p(0)" "n(0)" "y")
                              ((""
                                (assert)
                                ((""
                                  (case "p(0)(n(0))/=0")
                                  (("1"
                                    (ground)
                                    (("1"
                                      (skolem -1 "mm")
                                      (("1"
                                        (inst + "mm")
                                        (("1"
                                          (case "NOT mm > 1")
                                          (("1"
                                            (case "NOT mm = 1")
                                            (("1" (assertnil nil)
                                             ("2"
                                              (hide 1)
                                              (("2"
                                                (replace -1)
                                                (("2"
                                                  (assert)
                                                  (("2"
                                                    (expand
                                                     "max_linear_div_power?"
                                                     -2)
                                                    (("2"
                                                      (skeep)
                                                      (("2"
                                                        (assert)
                                                        (("2"
                                                          (expand
                                                           "^"
                                                           -4)
                                                          (("2"
                                                            (expand
                                                             "expt")
                                                            (("2"
                                                              (copy
                                                               "css")
                                                              (("2"
                                                                (expand
                                                                 "constructed_sturm_sequence?"
                                                                 -1)
                                                                (("2"
                                                                  (inst
                                                                   -5
                                                                   "y")
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (flatten)
                                                                      (("2"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (assert)
                                            (("2"
                                              (induct "j" 2)
                                              (("1" (assertnil nil)
                                               ("2"
                                                (skolem 1 "jj")
                                                (("2"
                                                  (flatten)
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (case "jj = 0")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (replace
                                                             -1)
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (lemma
                                                                 "max_linear_div_power_derivative")
                                                                (("1"
                                                                  (inst
                                                                   -
                                                                   "p(0)"
                                                                   "n(0)"
                                                                   "y"
                                                                   "mm")
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (flatten)
                                                                      (("1"
                                                                        (copy
                                                                         "css")
                                                                        (("1"
                                                                          (expand
                                                                           "constructed_sturm_sequence?"
                                                                           -1)
                                                                          (("1"
                                                                            (flatten)
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (assert)
                                                          (("2"
                                                            (case
                                                             "max_linear_div_power?(p(2 + jj), n(2 + jj), y)(mm - 1)")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (case
                                                                 "NOT 2+jj = m")
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil)
                                                                 ("2"
                                                                  (replace
                                                                   -1)
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (expand
                                                                       "max_linear_div_power?"
                                                                       -2)
                                                                      (("2"
                                                                        (case
                                                                         "polynomial(p(m),n(m)) = (LAMBDA (x:real): 0)")
                                                                        (("1"
                                                                          (replace
                                                                           -1)
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (skeep)
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (case
                                                                                   "EXISTS (xy:real): xy/=y AND polynomial(b,1+n(m)-mm)(xy)/=0")
                                                                                  (("1"
                                                                                    (skeep
                                                                                     -)
                                                                                    (("1"
                                                                                      (inst
                                                                                       -
                                                                                       "xy")
                                                                                      (("1"
                                                                                        (assert)
                                                                                        (("1"
                                                                                          (lemma
                                                                                           "nzreal_times_nzreal_is_nzreal")
                                                                                          (("1"
                                                                                            (inst?)
                                                                                            (("1"
                                                                                              (assert)
                                                                                              nil
                                                                                              nil)
                                                                                             ("2"
                                                                                              (lemma
                                                                                               "expt_nonzero")
                                                                                              (("2"
                                                                                                (inst?)
                                                                                                nil
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil)
                                                                                   ("2"
                                                                                    (hide-all-but
                                                                                     (1
                                                                                      2))
                                                                                    (("2"
                                                                                      (lemma
                                                                                       "poly_continuous")
                                                                                      (("2"
                                                                                        (inst
                                                                                         -
                                                                                         "b"
                                                                                         "1+n(m)-mm"
                                                                                         "y"
                                                                                         "abs(polynomial(b,1+n(m)-mm)(y))/2")
                                                                                        (("1"
                                                                                          (skeep)
                                                                                          (("1"
                                                                                            (inst
                                                                                             +
                                                                                             "y-delta/2")
                                                                                            (("1"
                                                                                              (assert)
                                                                                              (("1"
                                                                                                (inst
                                                                                                 -
                                                                                                 "y-delta/2")
                                                                                                (("1"
                                                                                                  (assert)
                                                                                                  (("1"
                                                                                                    (expand
                                                                                                     "abs"
                                                                                                     -1
                                                                                                     1)
                                                                                                    (("1"
                                                                                                      (expand
                                                                                                       "abs")
                                                                                                      (("1"
                                                                                                        (lift-if)
                                                                                                        (("1"
                                                                                                          (lift-if)
                                                                                                          (("1"
                                                                                                            (lift-if)
                                                                                                            (("1"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (assert)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (hide-all-but
                                                                           ("css"
                                                                            1))
                                                                          (("2"
                                                                            (expand
                                                                             "constructed_sturm_sequence?")
                                                                            (("2"
                                                                              (flatten)
                                                                              (("2"
                                                                                (replace
                                                                                 -5)
                                                                                (("2"
                                                                                  (expand
                                                                                   "polynomial"
                                                                                   +)
                                                                                  (("2"
                                                                                    (expand
                                                                                     "sigma")
                                                                                    (("2"
                                                                                      (expand
                                                                                       "sigma")
                                                                                      (("2"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (hide 4)
                                                              (("2"
                                                                (lemma
                                                                 "constructed_sturm_seq_repeated_root_mth")
                                                                (("2"
                                                                  (inst
                                                                   -
                                                                   "m-1"
                                                                   "m"
                                                                   "n"
                                                                   "p"
                                                                   "y"
                                                                   "mm")
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (inst
                                                                       -
                                                                       "1+jj")
                                                                      (("2"
                                                                        (assert)
                                                                        (("2"
                                                                          (skeep)
                                                                          (("2"
                                                                            (hide
                                                                             3)
                                                                            (("2"
                                                                              (rewrite
                                                                               "max_linear_div_power_rew"
                                                                               +)
                                                                              (("2"
                                                                                (assert)
                                                                                (("2"
                                                                                  (case
                                                                                   " EXISTS (b: [nat -> real],kz:nat):
        (FORALL (x):
           polynomial(p(2 + jj), n(2 + jj))(x) =
            ((x - y) ^ (mm - 1)) * polynomial(b, kz)(x))
         AND NOT polynomial(b, kz)(y) = 0")
                                                                                  (("1"
                                                                                    (skeep)
                                                                                    (("1"
                                                                                      (case
                                                                                       "EXISTS (RD:nat): RD<=kz AND b(RD)/=0 AND FORALL (i:nat): i>RD AND i<=kz IMPLIES b(i)=0")
                                                                                      (("1"
                                                                                        (skeep)
                                                                                        (("1"
                                                                                          (lemma
                                                                                           "polynomial_div_linear_power_degree")
                                                                                          (("1"
                                                                                            (inst
                                                                                             -
                                                                                             "y"
                                                                                             "p(2+jj)"
                                                                                             "b"
                                                                                             "n(2+jj)"
                                                                                             "RD"
                                                                                             "mm-1")
                                                                                            (("1"
                                                                                              (assert)
                                                                                              (("1"
                                                                                                (split
                                                                                                 -)
                                                                                                (("1"
                                                                                                  (flatten)
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    (("1"
                                                                                                      (inst
                                                                                                       +
                                                                                                       "b")
                                                                                                      (("1"
                                                                                                        (case
                                                                                                         "NOT 1+n(2+jj)-mm = RD")
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          nil
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (replace
                                                                                                           -1)
                                                                                                          (("2"
                                                                                                            (assert)
                                                                                                            (("2"
                                                                                                              (case
                                                                                                               "polynomial(b,RD) = polynomial(b,kz)")
                                                                                                              (("1"
                                                                                                                (ground)
                                                                                                                nil
                                                                                                                nil)
                                                                                                               ("2"
                                                                                                                (hide-all-but
                                                                                                                 (-4
                                                                                                                  -5
                                                                                                                  1))
                                                                                                                (("2"
                                                                                                                  (decompose-equality
                                                                                                                   +)
                                                                                                                  (("2"
                                                                                                                    (expand
                                                                                                                     "polynomial"
                                                                                                                     +
                                                                                                                     2)
                                                                                                                    (("2"
                                                                                                                      (lemma
                                                                                                                       "sigma_split")
                                                                                                                      (("2"
                                                                                                                        (inst?)
                                                                                                                        (("2"
                                                                                                                          (inst
                                                                                                                           -
                                                                                                                           "RD")
                                                                                                                          (("2"
                                                                                                                            (assert)
                                                                                                                            (("2"
                                                                                                                              (replaces
                                                                                                                               -1)
                                                                                                                              (("2"
                                                                                                                                (expand
                                                                                                                                 "polynomial")
                                                                                                                                (("2"
                                                                                                                                  (rewrite
                                                                                                                                   "sigma_restrict_eq_0")
                                                                                                                                  (("2"
                                                                                                                                    (hide
                                                                                                                                     2)
                                                                                                                                    (("2"
                                                                                                                                      (skosimp*)
                                                                                                                                      (("2"
                                                                                                                                        (assert)
                                                                                                                                        (("2"
                                                                                                                                          (inst
                                                                                                                                           -
                                                                                                                                           "i!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)
                                                                                                 ("2"
                                                                                                  (skeep)
                                                                                                  (("2"
                                                                                                    (inst
                                                                                                     -3
                                                                                                     "x")
                                                                                                    (("2"
                                                                                                      (replace
                                                                                                       -3)
                                                                                                      (("2"
                                                                                                        (case
                                                                                                         "polynomial(b,RD) = polynomial(b,kz)")
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          nil
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (hide-all-but
                                                                                                           (-1
                                                                                                            -2
                                                                                                            1))
                                                                                                          (("2"
                                                                                                            (expand
                                                                                                             "polynomial"
                                                                                                             +
                                                                                                             2)
                                                                                                            (("2"
                                                                                                              (decompose-equality
                                                                                                               +)
                                                                                                              (("2"
                                                                                                                (lemma
                                                                                                                 "sigma_split")
                                                                                                                (("2"
                                                                                                                  (inst?)
                                                                                                                  (("2"
                                                                                                                    (inst
                                                                                                                     -
                                                                                                                     "RD")
                                                                                                                    (("2"
                                                                                                                      (assert)
                                                                                                                      (("2"
                                                                                                                        (replaces
                                                                                                                         -1)
                                                                                                                        (("2"
                                                                                                                          (expand
                                                                                                                           "polynomial")
                                                                                                                          (("2"
                                                                                                                            (rewrite
                                                                                                                             "sigma_restrict_eq_0")
                                                                                                                            (("2"
                                                                                                                              (skosimp*)
                                                                                                                              (("2"
                                                                                                                                (inst
                                                                                                                                 -
                                                                                                                                 "i!1")
                                                                                                                                (("2"
                                                                                                                                  (assert)
                                                                                                                                  nil
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil)
                                                                                                 ("3"
                                                                                                  (copy
                                                                                                   "css")
                                                                                                  (("3"
                                                                                                    (expand
                                                                                                     "constructed_sturm_sequence?"
                                                                                                     -1)
                                                                                                    (("3"
                                                                                                      (flatten)
                                                                                                      (("3"
                                                                                                        (inst
                                                                                                         -
                                                                                                         "2+jj")
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          nil
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (assert)
                                                                                                          (("2"
                                                                                                            (postpone)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (postpone)
                                                                                        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)
                                               ("3" (postpone) nil nil)
                                               ("4" (postpone) nil nil)
                                               ("5" (postpone) nil nil)
                                               ("6" (postpone) nil nil)
                                               ("7" (postpone) nil nil)
                                               ("8" (postpone) nil nil)
                                               ("9" (postpone) nil nil)
                                               ("10"
                                                (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))
        nil))
      nil))
    nil)
   nil shostak))
 (constructed_sturm_seq_first_signs_eq 0
  (constructed_sturm_seq_first_signs_eq-1 nil 3589577529
   ("" (skeep)
    ((""
      (case "NOT (polynomial(p(0), n(0))(x) /= 0 AND
                                                  polynomial(p(0), n(0))(y) /= 0)")
      (("1" (hide 2)
        (("1" (inst-cp - "x")
          (("1" (inst - "y") (("1" (ground) nil nil)) nil)) nil))
        nil)
       ("2" (flatten)
        (("2" (assert)
          (("2" (inst-cp - "b")
            (("2" (assert)
              (("2" (flatten)
                (("2"
                  (case "polynomial(poly_deriv(p(0)),max(n(0)-1,0))(b) = 0")
                  (("1" (hide -5)
                    (("1" (expand "constructed_sturm_sequence?")
                      (("1" (flatten)
                        (("1" (assert)
                          (("1" (expand "max") (("1" (assertnil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (lemma "poly_continuous")
                    (("2"
                      (inst - "poly_deriv(p(0))" "max(n(0)-1,0)" "b"
                       "abs(polynomial(poly_deriv(p(0)),n(0)-1)(b))")
                      (("1" (skeep -)
                        (("1"
                          (case "EXISTS (deltiv:posreal): FORALL (x1:real): abs(b-x1)<deltiv IMPLIES (abs(b-x1)<delta AND x < x1 AND x1 < y)")
                          (("1"
                            (case "sign_ext(polynomial(p(0), n(0))(x)) =
                                                                   -sign_ext(polynomial(poly_deriv(p(0)), max(n(0)-1,0))(b))
                                                                   AND
                                                                   sign_ext(polynomial(p(0), n(0))(y)) =
                                                                    sign_ext(polynomial(poly_deriv(p(0)), max(n(0)-1,0))(b))")
                            (("1" (hide (-2 -3))
                              (("1"
                                (flatten)
                                (("1"
                                  (expand
                                   "constructed_sturm_sequence?")
                                  (("1"
                                    (flatten)
                                    (("1"
                                      (assert)
                                      (("1"
                                        (expand "max")
                                        (("1" (assertnil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (hide 6)
                              (("2"
                                (case
                                 "polynomial(poly_deriv(p(0)), max(n(0)-1,0))(b)>0")
                                (("1"
                                  (skeep -2)
                                  (("1"
                                    (case
                                     "FORALL (x1,x2:real): abs(x1-b)<deltiv AND abs(x2-b)<deltiv AND x1<x2 IMPLIES polynomial(p(0),n(0))(x1) < polynomial(p(0),n(0))(x2)")
                                    (("1"
                                      (inst-cp - "b-deltiv/2" "b")
                                      (("1"
                                        (inst-cp - "b" "b+deltiv/2")
                                        (("1"
                                          (label "hyplem" -1)
                                          (("1"
                                            (hide "hyplem")
                                            (("1"
                                              (assert)
                                              (("1"
                                                (split +)
                                                (("1"
                                                  (expand "sign_ext")
                                                  (("1"
                                                    (lift-if)
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (split 1)
                                                        (("1"
                                                          (propax)
                                                          nil
                                                          nil)
                                                         ("2"
                                                          (assert)
                                                          (("2"
                                                            (hide -1)
                                                            (("2"
                                                              (split -)
                                                              (("1"
                                                                (replace
                                                                 -7)
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (lemma
                                                                     "poly_intermediate_value_dec")
                                                                    (("1"
                                                                      (inst
                                                                       -
                                                                       "p(0)"
                                                                       "0"
                                                                       "n(0)"
                                                                       "x"
                                                                       "b-deltiv/2")
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (split
                                                                           -)
                                                                          (("1"
                                                                            (skeep
                                                                             -1)
                                                                            (("1"
                                                                              (inst
                                                                               -
                                                                               "cc")
                                                                              (("1"
                                                                                (inst
                                                                                 -
                                                                                 "cc")
                                                                                (("1"
                                                                                  (inst
                                                                                   -
                                                                                   "cc")
                                                                                  (("1"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (inst
                                                                             -
                                                                             "b-deltiv/2")
                                                                            (("2"
                                                                              (split
                                                                               -)
                                                                              (("1"
                                                                                (flatten)
                                                                                (("1"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (hide-all-but
                                                                                 1)
                                                                                (("2"
                                                                                  (grind)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (hide-all-but
                                                                 1)
                                                                (("2"
                                                                  (grind)
                                                                  nil
                                                                  nil))
                                                                nil)
                                                               ("3"
                                                                (expand
                                                                 "abs"
                                                                 1)
                                                                (("3"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (expand "sign_ext")
                                                  (("2"
                                                    (lift-if)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (split 1)
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (hide -3)
                                                            (("1"
                                                              (split -)
                                                              (("1"
                                                                (replace
                                                                 -8)
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (lemma
                                                                     "poly_intermediate_value_dec")
                                                                    (("1"
                                                                      (inst
                                                                       -
                                                                       "p(0)"
                                                                       "0"
                                                                       "n(0)"
                                                                       "b+deltiv/2"
                                                                       "y")
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (split
                                                                           -)
                                                                          (("1"
                                                                            (skeep
                                                                             -1)
                                                                            (("1"
                                                                              (inst
                                                                               -
                                                                               "cc")
                                                                              (("1"
                                                                                (inst
                                                                                 -
                                                                                 "cc")
                                                                                (("1"
                                                                                  (inst
                                                                                   -
                                                                                   "cc")
                                                                                  (("1"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (inst
                                                                             -
                                                                             "b+deltiv/2")
                                                                            (("2"
                                                                              (split
                                                                               -)
                                                                              (("1"
                                                                                (flatten)
                                                                                (("1"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (hide-all-but
                                                                                 1)
                                                                                (("2"
                                                                                  (grind)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (hide-all-but
                                                                 1)
                                                                (("2"
                                                                  (grind)
                                                                  nil
                                                                  nil))
                                                                nil)
                                                               ("3"
                                                                (hide-all-but
                                                                 1)
                                                                (("3"
                                                                  (grind)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (propax)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (skeep)
                                      (("2"
                                        (lemma
                                         "poly_strictly_increasing")
                                        (("2"
                                          (inst
                                           -
                                           "p(0)"
                                           "n(0)"
                                           "x1"
                                           "x2")
                                          (("2"
                                            (assert)
                                            (("2"
                                              (case "n(0)=0")
                                              (("1"
                                                (replaces -1)
                                                (("1"
                                                  (expand "polynomial")
                                                  (("1"
                                                    (expand "sigma")
                                                    (("1"
                                                      (expand "sigma")
                                                      (("1"
                                                        (propax)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (assert)
                                                (("2"
                                                  (skeep)
                                                  (("2"
                                                    (expand "max")
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (inst - "c")
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (split -)
                                                            (("1"
                                                              (inst
                                                               -
                                                               "c")
                                                              (("1"
                                                                (flatten)
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (expand
                                                                     "abs")
                                                                    (("1"
                                                                      (lift-if)
                                                                      (("1"
                                                                        (ground)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (expand
                                                               "abs"
                                                               (-1
                                                                -2
                                                                -3
                                                                -4
                                                                -5
                                                                1))
                                                              (("2"
                                                                (lift-if)
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (case
                                   "polynomial(poly_deriv(p(0)), max(n(0)-1,0))(b)<0")
                                  (("1"
                                    (hide 1)
                                    (("1"
                                      (skeep -2)
                                      (("1"
                                        (case
                                         "FORALL (x1,x2:real): abs(x1-b)<deltiv AND abs(x2-b)<deltiv AND x1<x2 IMPLIES polynomial(p(0),n(0))(x1) > polynomial(p(0),n(0))(x2)")
                                        (("1"
                                          (inst-cp - "b-deltiv/2" "b")
                                          (("1"
                                            (inst-cp
                                             -
                                             "b"
                                             "b+deltiv/2")
                                            (("1"
                                              (label "hyplem" -1)
                                              (("1"
                                                (hide "hyplem")
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (split +)
                                                    (("1"
                                                      (expand
                                                       "sign_ext")
                                                      (("1"
                                                        (lift-if)
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (split 1)
                                                            (("1"
                                                              (replace
                                                               -9)
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (lemma
                                                                   "poly_intermediate_value_inc")
                                                                  (("1"
                                                                    (inst
                                                                     -
                                                                     "p(0)"
                                                                     "0"
                                                                     "n(0)"
                                                                     "x"
                                                                     "b-deltiv/2")
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (split
                                                                         -)
                                                                        (("1"
                                                                          (skeep
                                                                           -1)
                                                                          (("1"
                                                                            (inst
                                                                             -
                                                                             "cc")
                                                                            (("1"
                                                                              (inst
                                                                               -
                                                                               "cc")
                                                                              (("1"
                                                                                (inst
                                                                                 -
                                                                                 "cc")
                                                                                (("1"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (inst
                                                                           -
                                                                           "b-deltiv/2")
                                                                          (("2"
                                                                            (split
                                                                             -3)
                                                                            (("1"
                                                                              (assert)
                                                                              (("1"
                                                                                (hide-all-but
                                                                                 2)
                                                                                (("1"
                                                                                  (grind)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (hide-all-but
                                                                               1)
                                                                              (("2"
                                                                                (grind)
                                                                                nil
                                                                                nil))
                                                                              nil)
                                                                             ("3"
                                                                              (assert)
                                                                              (("3"
                                                                                (hide-all-but
                                                                                 1)
                                                                                (("3"
                                                                                  (grind)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("3"
                                                                          (assert)
                                                                          (("3"
                                                                            (hide-all-but
                                                                             2)
                                                                            (("3"
                                                                              (grind)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (propax)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (expand
                                                       "sign_ext")
                                                      (("2"
                                                        (lift-if)
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (split 1)
                                                            (("1"
                                                              (propax)
                                                              nil
                                                              nil)
                                                             ("2"
                                                              (assert)
                                                              (("2"
                                                                (hide
                                                                 -2)
                                                                (("2"
                                                                  (split
                                                                   -)
                                                                  (("1"
                                                                    (replace
                                                                     -7)
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (lemma
                                                                         "poly_intermediate_value_inc")
                                                                        (("1"
                                                                          (inst
                                                                           -
                                                                           "p(0)"
                                                                           "0"
                                                                           "n(0)"
                                                                           "b+deltiv/2"
                                                                           "y")
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (split
                                                                               -)
                                                                              (("1"
                                                                                (skeep
                                                                                 -1)
                                                                                (("1"
                                                                                  (inst
                                                                                   -
                                                                                   "cc")
                                                                                  (("1"
                                                                                    (inst
                                                                                     -
                                                                                     "cc")
                                                                                    (("1"
                                                                                      (inst
                                                                                       -
                                                                                       "cc")
                                                                                      (("1"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (inst
                                                                                 -
                                                                                 "b+deltiv/2")
                                                                                (("2"
                                                                                  (split
                                                                                   -)
                                                                                  (("1"
                                                                                    (flatten)
                                                                                    (("1"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil)
                                                                                   ("2"
                                                                                    (hide-all-but
                                                                                     1)
                                                                                    (("2"
                                                                                      (grind)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (hide-all-but
                                                                     1)
                                                                    (("2"
                                                                      (grind)
                                                                      nil
                                                                      nil))
                                                                    nil)
                                                                   ("3"
                                                                    (hide-all-but
                                                                     1)
                                                                    (("3"
                                                                      (grind)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (skeep)
                                          (("2"
                                            (lemma
                                             "poly_strictly_decreasing")
                                            (("2"
                                              (inst
                                               -
                                               "p(0)"
                                               "n(0)"
                                               "x1"
                                               "x2")
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (case "n(0)=0")
                                                  (("1"
                                                    (replaces -1)
                                                    (("1"
                                                      (expand
                                                       "polynomial")
                                                      (("1"
                                                        (expand
                                                         "sigma")
                                                        (("1"
                                                          (expand
                                                           "sigma")
                                                          (("1"
                                                            (propax)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (assert)
                                                    (("2"
                                                      (skeep)
                                                      (("2"
                                                        (expand "max")
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (inst
                                                             -
                                                             "c")
                                                            (("2"
                                                              (assert)
                                                              (("2"
                                                                (split
                                                                 -)
                                                                (("1"
                                                                  (inst
                                                                   -
                                                                   "c")
                                                                  (("1"
                                                                    (flatten)
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (expand
                                                                         "abs")
                                                                        (("1"
                                                                          (assert)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (expand
                                                                   "abs"
                                                                   (-1
                                                                    -2
                                                                    -3
                                                                    -4
                                                                    -5
                                                                    1))
                                                                  (("2"
                                                                    (lift-if)
                                                                    (("2"
                                                                      (assert)
                                                                      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)
                             ("3" (assertnil nil))
                            nil)
                           ("2" (inst + "min(delta,min(b-x,y-b))")
                            (("1" (hide-all-but (-2 -3 1))
                              (("1" (grind) nil nil)) nil)
                             ("2" (hide-all-but (-2 -3 1))
                              (("2" (grind) nil nil)) nil))
                            nil))
                          nil))
                        nil)
                       ("2" (expand "abs" 1)
                        (("2" (lift-if)
                          (("2" (assert)
                            (("2" (split 1)
                              (("1" (propax) nil nil)
                               ("2"
                                (flatten)
                                (("2"
                                  (case "n(0)=0")
                                  (("1"
                                    (assert)
                                    (("1"
                                      (expand
                                       "constructed_sturm_sequence?")
                                      (("1" (propax) nil nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (expand "max")
                                    (("2" (assertnil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("3" (expand "constructed_sturm_sequence?")
                        (("3" (assertnil nil)) nil)
                       ("4" (expand "constructed_sturm_sequence?")
                        (("4" (flatten)
                          (("4" (expand "max") (("4" (assertnil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("3" (assertnil nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((polynomial const-decl "[real -> real]" polynomials "reals/")
    (sequence type-eq-decl nil sequences 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)
    (/= const-decl "boolean" notequal nil)
    (number nonempty-type-decl nil numbers nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans 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)
    (minus_real_is_real application-judgement "real" reals nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (int_max application-judgement "{k: int | i <= k AND j <= k}"
     real_defs nil)
    (rat_max application-judgement "{s: rat | s >= q AND s >= r}"
     real_defs nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (poly_deriv const-decl "real" polynomials "reals/")
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (constructed_sturm_sequence? const-decl "bool" sturm nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (n skolem-const-decl "[nat -> nat]" sturm nil)
    (> const-decl "bool" reals nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (p skolem-const-decl "[nat -> [nat -> real]]" sturm nil)
    (b skolem-const-decl "real" sturm nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (< const-decl "bool" reals nil)
    (poly_strictly_decreasing formula-decl nil polynomials "reals/")
    (poly_intermediate_value_inc formula-decl nil polynomials "reals/")
    (sigma def-decl "real" sigma "reals/")
    (real_times_real_is_real application-judgement "real" reals nil)
    (max_nnreal_0 formula-decl nil min_max "reals/")
    (poly_strictly_increasing formula-decl nil polynomials "reals/")
    (nzreal_times_nzreal_is_nzreal application-judgement "nzreal"
     real_types nil)
    (posreal_div_posreal_is_posreal application-judgement "posreal"
     real_types nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (abs_0_rew formula-decl nil abs_rews "ints/")
    (nonzero_abs_is_pos application-judgement "{y: posreal | y >= x}"
     real_defs nil)
    (poly_intermediate_value_dec formula-decl nil polynomials "reals/")
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (minus_nzreal_is_nzreal application-judgement "nzreal" real_types
     nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (sign_ext const-decl
     "{sig: real | (sig = -1 OR sig = 1 OR sig = 0) AND sig * x = abs(x)}"
     sign "reals/")
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (y skolem-const-decl "real" sturm nil)
    (x skolem-const-decl "real" sturm nil)
    (delta skolem-const-decl "posreal" sturm nil)
    (min const-decl "{p: real | p <= m AND p <= n}" real_defs nil)
    (<= const-decl "bool" reals nil)
    (max_npreal_0 formula-decl nil min_max "reals/")
    (poly_continuous formula-decl nil polynomials "reals/"))
   nil))
 (sturm_lem_no_roots 0
  (sturm_lem_no_roots-1 nil 3587229961
   ("" (skeep)
    (("" (name "f" "polynomial(p(0),n(0))")
      ((""
        (case "FORALL (j:nat): j<=m IMPLIES  number_sign_changes(LAMBDA (i): polynomial(p(i), n(i))(x), j)`num =
                            number_sign_changes(LAMBDA (i): polynomial(p(i), n(i))(y), j)`num AND sign_ext(number_sign_changes(LAMBDA (i): polynomial(p(i), n(i))(x), j)`lastnz) = sign_ext(number_sign_changes(LAMBDA (i): polynomial(p(i), n(i))(y), j)`lastnz)")
        (("1" (inst - "m")
          (("1" (expand "sturm_sig") (("1" (assertnil nil)) nil))
          nil)
         ("2" (induct "j")
          (("1" (assert)
            (("1" (split)
              (("1" (expand "number_sign_changes")
                (("1" (propax) nil nil)) nil)
               ("2" (expand "number_sign_changes")
                (("2" (replace -1)
                  (("2" (lemma "poly_intermediate_value_inc")
                    (("2" (inst - "p(0)" "0" "n(0)" "x" "y")
                      (("2" (assert)
                        (("2" (lemma "poly_intermediate_value_dec")
                          (("2" (inst - "p(0)" "0" "n(0)" "x" "y")
                            (("2" (assert)
                              (("2"
                                (split -)
                                (("1"
                                  (skeep -1)
                                  (("1"
                                    (inst - "cc" "0")
                                    (("1" (assertnil nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (assert)
                                  (("2"
                                    (split -)
                                    (("1"
                                      (skeep -1)
                                      (("1"
                                        (inst - "cc" "0")
                                        (("1" (assertnil nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (replace -1)
                                      (("2"
                                        (hide-all-but (1 2 3))
                                        (("2" (grind) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("3"
                                  (assert)
                                  (("3"
                                    (split -)
                                    (("1"
                                      (skeep -1)
                                      (("1"
                                        (inst - "cc" "0")
                                        (("1" (assertnil nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (expand "sign_ext")
                                      (("2" (assertnil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (skolem 1 "jj")
            (("2" (hide 2)
              (("2" (assert)
                (("2" (flatten)
                  (("2" (assert)
                    (("2" (flatten)
                      (("2"
                        (name "G"
                              "LAMBDA (xx:real): LAMBDA (i): polynomial(p(i),n(i))(xx)")
                        (("2" (copy -1)
                          (("2" (decompose-equality -1)
                            (("2" (inst-cp - "x")
                              (("2"
                                (inst - "y")
                                (("2"
                                  (replaces -1)
                                  (("2"
                                    (replaces -1)
                                    (("2"
                                      (case
                                       "NOT sign_ext(G(x)(1+jj)) = sign_ext(G(y)(1+jj))")
                                      (("1"
                                        (hide 2)
                                        (("1"
                                          (expand "G" 1)
                                          (("1"
                                            (inst-cp - "x" "1+jj")
                                            (("1"
                                              (inst-cp - "y" "1+jj")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (flatten)
                                                  (("1"
                                                    (expand
                                                     "sign_ext"
                                                     1)
                                                    (("1"
                                                      (lift-if)
                                                      (("1"
                                                        (lift-if)
                                                        (("1"
                                                          (lift-if)
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (ground)
                                                              (("1"
                                                                (lemma
                                                                 "poly_intermediate_value_inc")
                                                                (("1"
                                                                  (inst
                                                                   -
                                                                   "p(1+jj)"
                                                                   "0"
                                                                   "n(1+jj)"
                                                                   "x"
                                                                   "y")
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (skeep
                                                                       -1)
                                                                      (("1"
                                                                        (inst
                                                                         -
                                                                         "cc"
                                                                         "1+jj")
                                                                        (("1"
                                                                          (assert)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (lemma
                                                                 "poly_intermediate_value_dec")
                                                                (("2"
                                                                  (inst
                                                                   -
                                                                   "p(1+jj)"
                                                                   "0"
                                                                   "n(1+jj)"
                                                                   "x"
                                                                   "y")
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (skeep
                                                                       -1)
                                                                      (("2"
                                                                        (inst
                                                                         -
                                                                         "cc"
                                                                         "1+jj")
                                                                        (("2"
                                                                          (assert)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (expand
                                         "number_sign_changes"
                                         +)
                                        (("2"
                                          (assert)
                                          (("2"
                                            (lift-if)
                                            (("2"
                                              (lift-if)
                                              (("2"
                                                (lift-if)
                                                (("2"
                                                  (assert)
                                                  (("2"
                                                    (ground)
                                                    (("1"
                                                      (inst
                                                       -
                                                       "y"
                                                       "1+jj")
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (expand
                                                           "G"
                                                           -1)
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (expand
                                                       "sign_ext"
                                                       -5)
                                                      (("2"
                                                        (assert)
                                                        (("2"
                                                          (lift-if)
                                                          (("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("3"
                                                      (inst
                                                       -
                                                       "x"
                                                       "1+jj")
                                                      (("3"
                                                        (assert)
                                                        (("3"
                                                          (expand
                                                           "G"
                                                           -1)
                                                          (("3"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("4"
                                                      (lift-if)
                                                      (("4"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil)
                                                     ("5"
                                                      (lift-if)
                                                      (("5"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil)
                                                     ("6"
                                                      (expand
                                                       "sign_ext"
                                                       -5)
                                                      (("6"
                                                        (assert)
                                                        (("6"
                                                          (lift-if)
                                                          (("6"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("7"
                                                      (lift-if)
                                                      (("7"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil)
                                                     ("8"
                                                      (lift-if)
                                                      (("8"
                                                        (lift-if)
                                                        (("8"
                                                          (assert)
                                                          (("8"
                                                            (split +)
                                                            (("1"
                                                              (propax)
                                                              nil
                                                              nil)
                                                             ("2"
                                                              (flatten)
                                                              (("2"
                                                                (lift-if)
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("9"
                                                      (lift-if)
                                                      (("9"
                                                        (lift-if)
                                                        (("9"
                                                          (lift-if)
                                                          (("9"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("10"
                                                      (lift-if)
                                                      (("10"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil)
                                                     ("11"
                                                      (lift-if)
                                                      (("11"
                                                        (lift-if)
                                                        (("11"
                                                          (lift-if)
                                                          (("11"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("12"
                                                      (lift-if)
                                                      (("12"
                                                        (lift-if)
                                                        (("12"
                                                          (lift-if)
                                                          (("12"
                                                            (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))
      nil))
    nil)
   ((polynomial const-decl "[real -> real]" polynomials "reals/")
    (sequence type-eq-decl nil sequences 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)
    (= const-decl "[T, T -> boolean]" equalities 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)
    (pred type-eq-decl nil defined_types nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (poly_intermediate_value_dec formula-decl nil polynomials "reals/")
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (poly_intermediate_value_inc formula-decl nil polynomials "reals/")
    (NOT const-decl "[bool -> bool]" booleans nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (G skolem-const-decl "[real -> [nat -> real]]" sturm nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     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)
    (sturm_sig const-decl "nat" sturm nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (NSC type-eq-decl nil number_sign_changes nil)
    (number_sign_changes def-decl "NSC" number_sign_changes nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (sign_ext const-decl
     "{sig: real | (sig = -1 OR sig = 1 OR sig = 0) AND sig * x = abs(x)}"
     sign "reals/"))
   shostak))
 (constructed_sturm_lem_one_simple_root_TCC1 0
  (constructed_sturm_lem_one_simple_root_TCC1-1 nil 3592820375
   ("" (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_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (/= const-decl "boolean" notequal nil)
    (constructed_sturm_sequence? const-decl "bool" sturm nil)
    (^ const-decl "real" exponentiation nil)
    (polynomial const-decl "[real -> real]" polynomials "reals/")
    (real_times_real_is_real application-judgement "real" reals nil))
   nil))
 (constructed_sturm_lem_one_simple_root 0
  (constructed_sturm_lem_one_simple_root-1 nil 3592130472
   ("" (skeep)
    (("" (label "xy" -1)
      (("" (label "xb" -2)
        (("" (label "by" -3)
          (("" (label "cb" -4)
            (("" (label "sf" -5)
              (("" (label "css" -6)
                (("" (skoletin 1)
                  (("" (label "nscname" -1)
                    (("" (lemma "nsc_regular_swap")
                      ((""
                        (inst - "LAMBDA (i): polynomial(p(i), n(i))(x)"
                         "LAMBDA (i): polynomial(p(i), n(i))(y)" "m-1"
                         "m-1")
                        (("1" (split -)
                          (("1" (skoletin -1)
                            (("1" (skoletin -1)
                              (("1"
                                (flatten)
                                (("1"
                                  (assert)
                                  (("1"
                                    (split +)
                                    (("1"
                                      (split -)
                                      (("1"
                                        (replace "nscname" +)
                                        (("1" (assertnil nil))
                                        nil)
                                       ("2"
                                        (expand
                                         "constructed_sturm_sequence?")
                                        (("2"
                                          (flatten)
                                          (("2" (assertnil nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (hide -1)
                                      (("2"
                                        (replace "nscname" +)
                                        (("2"
                                          (assert)
                                          (("2"
                                            (replace -2 :dir rl)
                                            (("2"
                                              (replace -3 :dir rl)
                                              (("2"
                                                (replace -1 +)
                                                (("2"
                                                  (assert)
                                                  (("2"
                                                    (case "NOT m-1>=1")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (expand
                                                         "constructed_sturm_sequence?")
                                                        (("1"
                                                          (propax)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (assert)
                                                      (("2"
                                                        (hide -2)
                                                        (("2"
                                                          (lift-if)
                                                          (("2"
                                                            (lift-if)
                                                            (("2"
                                                              (lift-if)
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (copy
                                                                   "cb")
                                                                  (("2"
                                                                    (inst-cp
                                                                     -
                                                                     "x"
                                                                     "0")
                                                                    (("2"
                                                                      (inst
                                                                       -
                                                                       "y"
                                                                       "0")
                                                                      (("2"
                                                                        (assert)
                                                                        (("2"
                                                                          (case
                                                                           "NOT (polynomial(p(0), n(0))(b) = 0 IFF max_linear_div_power?(p(0),n(0),b)(1))")
                                                                          (("1"
                                                                            (hide
                                                                             4)
                                                                            (("1"
                                                                              (ground)
                                                                              (("1"
                                                                                (lemma
                                                                                 "poly_max_zero_power")
                                                                                (("1"
                                                                                  (inst?)
                                                                                  (("1"
                                                                                    (assert)
                                                                                    (("1"
                                                                                      (split
                                                                                       -)
                                                                                      (("1"
                                                                                        (skosimp*)
                                                                                        (("1"
                                                                                          (case
                                                                                           "NOT m!1 > 1")
                                                                                          (("1"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil)
                                                                                           ("2"
                                                                                            (expand
                                                                                             "max_linear_div_power?"
                                                                                             -2)
                                                                                            (("2"
                                                                                              (skosimp*)
                                                                                              (("2"
                                                                                                (copy
                                                                                                 "css")
                                                                                                (("2"
                                                                                                  (label
                                                                                                   "dippydan"
                                                                                                   -1)
                                                                                                  (("2"
                                                                                                    (expand
                                                                                                     "constructed_sturm_sequence?"
                                                                                                     -1)
                                                                                                    (("2"
                                                                                                      (flatten)
                                                                                                      (("2"
                                                                                                        (replace
                                                                                                         -3)
                                                                                                        (("2"
                                                                                                          (replace
                                                                                                           -4)
                                                                                                          (("2"
                                                                                                            (hide
                                                                                                             "dippydan")
                                                                                                            (("2"
                                                                                                              (inst
                                                                                                               -4
                                                                                                               "b")
                                                                                                              (("2"
                                                                                                                (replace
                                                                                                                 -4
                                                                                                                 +)
                                                                                                                (("2"
                                                                                                                  (assert)
                                                                                                                  (("2"
                                                                                                                    (expand
                                                                                                                     "^"
                                                                                                                     "sf")
                                                                                                                    (("2"
                                                                                                                      (expand
                                                                                                                       "expt")
                                                                                                                      (("2"
                                                                                                                        (propax)
                                                                                                                        nil
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (copy
                                                                                         "css")
                                                                                        (("2"
                                                                                          (expand
                                                                                           "constructed_sturm_sequence?"
                                                                                           -1)
                                                                                          (("2"
                                                                                            (flatten)
                                                                                            (("2"
                                                                                              (inst
                                                                                               -
                                                                                               "0")
                                                                                              (("2"
                                                                                                (assert)
                                                                                                nil
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (expand
                                                                                 "max_linear_div_power?")
                                                                                (("2"
                                                                                  (skosimp*)
                                                                                  (("2"
                                                                                    (inst
                                                                                     -
                                                                                     "b")
                                                                                    (("2"
                                                                                      (replace
                                                                                       -2)
                                                                                      (("2"
                                                                                        (assert)
                                                                                        (("2"
                                                                                          (expand
                                                                                           "^"
                                                                                           +)
                                                                                          (("2"
                                                                                            (expand
                                                                                             "expt"
                                                                                             +)
                                                                                            (("2"
                                                                                              (propax)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("3"
                                                                                (expand
                                                                                 "max_linear_div_power?")
                                                                                (("3"
                                                                                  (skosimp*)
                                                                                  (("3"
                                                                                    (inst
                                                                                     -
                                                                                     "b")
                                                                                    (("3"
                                                                                      (replace
                                                                                       -2)
                                                                                      (("3"
                                                                                        (assert)
                                                                                        (("3"
                                                                                          (expand
                                                                                           "^"
                                                                                           +)
                                                                                          (("3"
                                                                                            (expand
                                                                                             "expt"
                                                                                             +)
                                                                                            (("3"
                                                                                              (propax)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (ground)
                                                                            (("1"
                                                                              (lemma
                                                                               " max_linear_div_power_sign_change")
                                                                              (("1"
                                                                                (inst
                                                                                 -
                                                                                 "p(0)"
                                                                                 "n(0)"
                                                                                 "x"
                                                                                 "b"
                                                                                 "y"
                                                                                 "1")
                                                                                (("1"
                                                                                  (assert)
                                                                                  (("1"
                                                                                    (copy
                                                                                     "cb")
                                                                                    (("1"
                                                                                      (skeep)
                                                                                      (("1"
                                                                                        (inst
                                                                                         -
                                                                                         "r"
                                                                                         "0")
                                                                                        (("1"
                                                                                          (assert)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (expand
                                                                               "sign_ext"
                                                                               -1)
                                                                              (("2"
                                                                                (lift-if)
                                                                                (("2"
                                                                                  (lift-if)
                                                                                  (("2"
                                                                                    (lift-if)
                                                                                    (("2"
                                                                                      (assert)
                                                                                      (("2"
                                                                                        (ground)
                                                                                        (("1"
                                                                                          (lemma
                                                                                           "poly_intermediate_value_inc")
                                                                                          (("1"
                                                                                            (inst
                                                                                             -
                                                                                             "p(0)"
                                                                                             "0"
                                                                                             "n(0)"
                                                                                             "x"
                                                                                             "y")
                                                                                            (("1"
                                                                                              (assert)
                                                                                              (("1"
                                                                                                (skosimp*)
                                                                                                (("1"
                                                                                                  (inst
                                                                                                   "cb"
                                                                                                   "cc!1"
--> --------------------

--> maximum size reached

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

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

¤ Dauer der Verarbeitung: 0.682 Sekunden  (vorverarbeitet am  2026-04-25) ¤

*© Formatika GbR, Deutschland






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.