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


Impressum sturmtarski.prf

  Sprache: Lisp
 

(sturmtarski
 (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_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))
   nil))
 (constructed_sturm_sequence?_TCC2 0
  (constructed_sturm_sequence?_TCC2-1 nil 3589569590
   ("" (subtype-tcc) nil 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)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers 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_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (/= const-decl "boolean" notequal nil))
   nil))
 (constructed_sturm_sequence?_TCC4 0
  (constructed_sturm_sequence?_TCC4-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)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (/= const-decl "boolean" notequal nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil))
   nil))
 (constructed_sturm_sequence?_TCC5 0
  (constructed_sturm_sequence?_TCC5-1 nil 3619446702
   ("" (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)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers 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)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (/= const-decl "boolean" notequal nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil))
   nil))
 (constructed_sturm_sequence?_TCC6 0
  (constructed_sturm_sequence?_TCC6-1 nil 3619446702
   ("" (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)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (/= const-decl "boolean" notequal nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers 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 -11 "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")
                                        (("1"
                                          (assert)
                                          (("1"
                                            (inst - "x")
                                            (("1"
                                              (assert)
                                              (("1"
                                                (replace -1)
                                                (("1"
                                                  (replace -5)
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (case
                                                       "polynomial(pd`rem, pd`rdeg)(x) = 0 IFF polynomial(-c*pd`rem, pd`rdeg)(x) = 0")
                                                      (("1"
                                                        (replace -1 +)
                                                        (("1"
                                                          (replace
                                                           -14
                                                           +
                                                           :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)
                                         ("2"
                                          (assert)
                                          (("2"
                                            (case "NOT i = 1")
                                            (("1" (assertnil nil)
                                             ("2"
                                              (replace -1)
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (replace -13)
                                                  (("2"
                                                    (case
                                                     "polynomial(pd`rem, pd`rdeg)(x) = 0 IFF polynomial(-c*pd`rem, pd`rdeg)(x) = 0")
                                                    (("1"
                                                      (replace
                                                       -1
                                                       :dir
                                                       rl)
                                                      (("1"
                                                        (inst - "x")
                                                        (("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)
   ((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)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers 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" sturmtarski 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 "posnat" sturmtarski nil)
    (j skolem-const-decl "upto(m)" sturmtarski nil)
    (i skolem-const-decl "nat" sturmtarski 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" sturmtarski nil)
    (constructed_sturm_sequence? const-decl "bool" sturmtarski nil)
    (poly_divide_def formula-decl nil polynomial_division "Sturm/")
    (real_times_real_is_real application-judgement "real" reals nil)
    (minus_nzreal_is_nzreal application-judgement "nzreal" real_types
     nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (odd_plus_odd_is_even application-judgement "even_int" integers
     nil)
    (NOT const-decl "[bool -> bool]" booleans 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)
    (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)
    (subrange type-eq-decl nil integers nil)
    (i skolem-const-decl "nat" sturmtarski 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 "Sturm/")
    (/= const-decl "boolean" notequal nil)
    (DivType type-eq-decl nil polynomial_division "Sturm/")
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   nil))
 (default_root_degree?_TCC1 0
  (default_root_degree?_TCC1-1 nil 3617013590
   ("" (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)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (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)
    (^ const-decl "real" exponentiation nil)
    (polynomial const-decl "[real -> real]" polynomials "reals/")
    (/= const-decl "boolean" notequal nil)
    (real_times_real_is_real application-judgement "real" reals nil))
   nil))
 (default_root_degree?_TCC2 0
  (default_root_degree?_TCC2-1 nil 3617610964
   ("" (subtype-tcc) nil nil)
   ((/= const-decl "boolean" notequal 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_seq_root_degrees_TCC1 0
  (constructed_sturm_seq_root_degrees_TCC1-1 nil 3617013872
   ("" (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)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (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)
    (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 "boolean" notequal nil)
    (constructed_sturm_sequence? const-decl "bool" sturmtarski nil)
    (^ const-decl "real" exponentiation nil)
    (polynomial const-decl "[real -> real]" polynomials "reals/")
    (default_root_degree? const-decl "bool" sturmtarski nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (int_minus_int_is_int application-judgement "int" integers nil))
   nil))
 (constructed_sturm_seq_root_degrees 0
  (constructed_sturm_seq_root_degrees-2 nil 3617123921
   ("" (skeep)
    (("" (label "css" -1)
      (("" (case "g(k)=0")
        (("1" (expand "constructed_sturm_sequence?")
          (("1" (ground) nil nil)) nil)
         ("2"
          (name "dd"
                "IF polynomial(g,k)(y)=0 THEN root_degree(p(0),n(0))(y) ELSE max(root_degree(p(0), n(0))(y) - 1, 0) ENDIF")
          (("2"
            (case "FORALL (k,i:nat): i<=k AND k+1<m IMPLIES ((root_degree(p(i),n(i))(y)=dd OR root_degree(p(i+1),n(i+1))(y)=dd) AND (root_degree(p(i),n(i))(y)>=dd AND root_degree(p(i+1),n(i+1))(y)>=dd))")
            (("1" (case "root_degree(p(m-1),n(m-1))(y)=dd")
              (("1" (label "igz" -1)
                (("1" (hide "igz")
                  (("1" (assert)
                    (("1" (inst - "m-2" _)
                      (("1" (assert)
                        (("1" (lift-if)
                          (("1" (split -)
                            (("1" (flatten)
                              (("1"
                                (lemma "root_degree_pos")
                                (("1"
                                  (inst?)
                                  (("1"
                                    (assert)
                                    (("1"
                                      (hide 3)
                                      (("1"
                                        (expand "default_root_degree?")
                                        (("1"
                                          (assert)
                                          (("1"
                                            (invoke
                                             (case "NOT (%1)")
                                             (! 2 1))
                                            (("1"
                                              (hide 3)
                                              (("1"
                                                (copy -5)
                                                (("1"
                                                  (expand
                                                   "constructed_sturm_sequence?"
                                                   -1)
                                                  (("1"
                                                    (flatten)
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (replace -4 +)
                                                        (("1"
                                                          (lemma
                                                           "root_degree_mult")
                                                          (("1"
                                                            (inst?)
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (inst
                                                                 -
                                                                 "y")
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (split
                                                                     -1)
                                                                    (("1"
                                                                      (replace
                                                                       -6)
                                                                      (("1"
                                                                        (replaces
                                                                         -1)
                                                                        (("1"
                                                                          (rewrite
                                                                           "root_degree_deriv")
                                                                          (("1"
                                                                            (ground)
                                                                            nil
                                                                            nil)
                                                                           ("2"
                                                                            (inst
                                                                             -
                                                                             "0")
                                                                            nil
                                                                            nil)
                                                                           ("3"
                                                                            (lemma
                                                                             "root_degree_pos")
                                                                            (("3"
                                                                              (inst?)
                                                                              (("3"
                                                                                (assert)
                                                                                (("3"
                                                                                  (inst
                                                                                   -
                                                                                   "0")
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (inst
                                                                       -
                                                                       "1")
                                                                      (("2"
                                                                        (assert)
                                                                        (("2"
                                                                          (replace
                                                                           -5)
                                                                          (("2"
                                                                            (replace
                                                                             -4
                                                                             -1)
                                                                            (("2"
                                                                              (flatten)
                                                                              (("2"
                                                                                (expand
                                                                                 "polynomial_prod"
                                                                                 1)
                                                                                (("2"
                                                                                  (expand
                                                                                   "max"
                                                                                   1)
                                                                                  (("2"
                                                                                    (expand
                                                                                     "sigma"
                                                                                     1)
                                                                                    (("2"
                                                                                      (expand
                                                                                       "sigma"
                                                                                       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"
                                              (replace -1)
                                              (("2"
                                                (split +)
                                                (("1"
                                                  (skeep)
                                                  (("1"
                                                    (replace -5)
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (inst-cp
                                                         -
                                                         "i-1")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (flatten)
                                                            (("1"
                                                              (inst-cp
                                                               -
                                                               "i")
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (ground)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (reveal "igz")
                                                  (("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (flatten)
                              (("2"
                                (assert)
                                (("2"
                                  (hide 3)
                                  (("2"
                                    (replace -1)
                                    (("2"
                                      (expand "default_root_degree?")
                                      (("2"
                                        (invoke
                                         (case "NOT (%1)")
                                         (! 3 1))
                                        (("1"
                                          (hide 4)
                                          (("1"
                                            (assert)
                                            (("1"
                                              (flatten)
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (case
                                                   "polynomial(p(0),n(0))(y)/=0")
                                                  (("1"
                                                    (flatten)
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (lemma
                                                         "root_degree_pos")
                                                        (("1"
                                                          (inst?)
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (copy -4)
                                                              (("1"
                                                                (split
                                                                 -)
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil)
                                                                 ("2"
                                                                  (expand
                                                                   "constructed_sturm_sequence?")
                                                                  (("2"
                                                                    (flatten)
                                                                    (("2"
                                                                      (inst
                                                                       -
                                                                       "0")
                                                                      (("2"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (assert)
                                                    (("2"
                                                      (hide 2)
                                                      (("2"
                                                        (lemma
                                                         "root_degree_pos")
                                                        (("2"
                                                          (inst?)
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (lemma
                                                               "root_degree_pos")
                                                              (("2"
                                                                (inst
                                                                 -
                                                                 "p(0)"
                                                                 "n(0)"
                                                                 "y")
                                                                (("2"
                                                                  (assert)
                                                                  (("2"
                                                                    (split
                                                                     -1)
                                                                    (("1"
                                                                      (expand
                                                                       "max"
                                                                       -2)
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (copy
                                                                             -4)
                                                                            (("1"
                                                                              (expand
                                                                               "constructed_sturm_sequence?"
                                                                               -1)
                                                                              (("1"
                                                                                (flatten)
                                                                                (("1"
                                                                                  (assert)
                                                                                  (("1"
                                                                                    (replace
                                                                                     -4)
                                                                                    (("1"
                                                                                      (replace
                                                                                       -3)
                                                                                      (("1"
                                                                                        (rewrite
                                                                                         "root_degree_mult")
                                                                                        (("1"
                                                                                          (rewrite
                                                                                           "root_degree_deriv")
                                                                                          (("1"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil)
                                                                                           ("2"
                                                                                            (inst
                                                                                             -
                                                                                             "0")
                                                                                            nil
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (inst
                                                                                           -
                                                                                           "0")
                                                                                          (("2"
                                                                                            (expand
                                                                                             "poly_deriv"
                                                                                             1)
                                                                                            (("2"
                                                                                              (assert)
                                                                                              (("2"
                                                                                                (ground)
                                                                                                (("2"
                                                                                                  (mult-by
                                                                                                   1
                                                                                                   "n(0)")
                                                                                                  (("2"
                                                                                                    (assert)
                                                                                                    nil
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (expand
                                                                       "constructed_sturm_sequence?")
                                                                      (("2"
                                                                        (flatten)
                                                                        (("2"
                                                                          (inst
                                                                           -5
                                                                           "0")
                                                                          (("2"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (replace -1)
                                          (("2"
                                            (assert)
                                            (("2"
                                              (split +)
                                              (("1"
                                                (hide -1)
                                                (("1"
                                                  (skeep)
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (split +)
                                                      (("1"
                                                        (flatten)
                                                        (("1"
                                                          (inst
                                                           -
                                                           "i-1")
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil)
                                                           ("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (flatten)
                                                        (("2"
                                                          (inst - "i")
                                                          (("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (reveal "igz")
                                                (("2"
                                                  (propax)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (expand "constructed_sturm_sequence?")
                        (("2" (assertnil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (hide (3 4))
                (("2" (inst - "m-2" "m-2")
                  (("1" (assert)
                    (("1" (flatten)
                      (("1" (hide -2)
                        (("1" (hide -3)
                          (("1" (expand "constructed_sturm_sequence?")
                            (("1" (flatten)
                              (("1"
                                (inst -10 "m")
                                (("1"
                                  (assert)
                                  (("1"
                                    (skeep)
                                    (("1"
                                      (name
                                       "pd"
                                       "poly_divide(p(m - 2), n(m - 2))(p(m - 1), n(m - 1))
                              (0)")
                                      (("1"
                                        (assert)
                                        (("1"
                                          (lemma "poly_divide_def")
                                          (("1"
                                            (inst?)
                                            (("1"
                                              (inst-cp - "m-1")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (replace -2)
                                                  (("1"
                                                    (name
                                                     "pr"
                                                     "polynomial_prod(pd`quot,pd`qdeg,p(m-1),n(m-1))")
                                                    (("1"
                                                      (case
                                                       "NOT polynomial(pd`rem, pd`rdeg) = (LAMBDA (xyz:real): 0)")
                                                      (("1"
                                                        (decompose-equality
                                                         1)
                                                        (("1"
                                                          (mult-by
                                                           1
                                                           "-c")
                                                          (("1"
                                                            (lemma
                                                             "scal_polynomial2")
                                                            (("1"
                                                              (inst?)
                                                              (("1"
                                                                (inst
                                                                 -
                                                                 "x!1")
                                                                (("1"
                                                                  (replaces
                                                                   -1
                                                                   :dir
                                                                   rl)
                                                                  (("1"
                                                                    (replace
                                                                     -14
                                                                     :dir
                                                                     rl)
                                                                    (("1"
                                                                      (expand
                                                                       "polynomial"
                                                                       +
                                                                       1)
                                                                      (("1"
                                                                        (expand
                                                                         "sigma"
                                                                         +
                                                                         1)
                                                                        (("1"
                                                                          (expand
                                                                           "sigma"
                                                                           +
                                                                           1)
                                                                          (("1"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (replace -1)
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (name
                                                             "rd"
                                                             "root_degree(p(m - 1), n(m - 1))(y)")
                                                            (("2"
                                                              (typepred
                                                               "rd")
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (flatten)
                                                                  (("2"
                                                                    (hide
                                                                     -3)
                                                                    (("2"
                                                                      (skeep)
                                                                      (("2"
                                                                        (case
                                                                         "EXISTS (kk:nat): kk<=pd`qdeg AND pd`quot(kk)/=0 AND polynomial(pd`quot, pd`qdeg) = polynomial(pd`quot,kk)")
                                                                        (("1"
                                                                          (skeep)
                                                                          (("1"
                                                                            (replace
                                                                             -2)
                                                                            (("1"
                                                                              (assert)
                                                                              (("1"
                                                                                (name
                                                                                 "newprod"
                                                                                 "polynomial_prod(b,n(m-1)-rd,pd`quot,kk)")
                                                                                (("1"
                                                                                  (lemma
                                                                                   "root_degree_lower_bound")
                                                                                  (("1"
                                                                                    (inst
                                                                                     -
                                                                                     "p(m-2)"
                                                                                     "rd"
                                                                                     "n(m-2)"
                                                                                     "y"
                                                                                     "n(m-1)-rd+kk")
                                                                                    (("1"
                                                                                      (split
                                                                                       -1)
                                                                                      (("1"
                                                                                        (flatten)
                                                                                        (("1"
                                                                                          (assert)
                                                                                          nil
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (inst
                                                                                         -
                                                                                         "m-2")
                                                                                        (("2"
                                                                                          (inst
                                                                                           -
                                                                                           "m-2")
                                                                                          (("2"
                                                                                            (inst
                                                                                             -
                                                                                             "m-2")
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("3"
                                                                                        (inst
                                                                                         +
                                                                                         "newprod")
                                                                                        (("3"
                                                                                          (assert)
                                                                                          (("3"
                                                                                            (split
                                                                                             +)
                                                                                            (("1"
                                                                                              (expand
                                                                                               "newprod"
                                                                                               1)
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "polynomial_prod"
                                                                                                 1)
                                                                                                (("1"
                                                                                                  (expand
                                                                                                   "max"
                                                                                                   -1)
                                                                                                  (("1"
                                                                                                    (expand
                                                                                                     "sigma"
                                                                                                     -1)
                                                                                                    (("1"
                                                                                                      (expand
                                                                                                       "sigma"
                                                                                                       -1)
                                                                                                      (("1"
                                                                                                        (assert)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil)
                                                                                             ("2"
                                                                                              (skeep)
                                                                                              (("2"
                                                                                                (inst
                                                                                                 -9
                                                                                                 "x")
                                                                                                (("2"
                                                                                                  (replace
                                                                                                   -9)
                                                                                                  (("2"
                                                                                                    (inst
                                                                                                     -5
                                                                                                     "x")
                                                                                                    (("2"
                                                                                                      (replace
                                                                                                       -5)
                                                                                                      (("2"
                                                                                                        (expand
                                                                                                         "newprod"
                                                                                                         +)
                                                                                                        (("2"
                                                                                                          (rewrite
                                                                                                           "polynomial_prod")
                                                                                                          (("2"
                                                                                                            (rewrite
                                                                                                             "polynomial_prod_def"
                                                                                                             :dir
                                                                                                             rl)
                                                                                                            (("2"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (case
                                                                           "EXISTS (kk:nat): kk<=pd`qdeg AND pd`quot(kk)/=0")
                                                                          (("1"
                                                                            (hide-all-but
                                                                             (-1
                                                                              1))
                                                                            (("1"
                                                                              (case
                                                                               "EXISTS (kk:nat): kk<=pd`qdeg AND pd`quot(kk)/=0 AND FORALL (ii:nat): ii>kk AND ii<=pd`qdeg IMPLIES pd`quot(ii)=0")
                                                                              (("1"
                                                                                (hide
                                                                                 -2)
                                                                                (("1"
                                                                                  (skeep)
                                                                                  (("1"
                                                                                    (inst
                                                                                     +
                                                                                     "kk")
                                                                                    (("1"
                                                                                      (assert)
                                                                                      (("1"
                                                                                        (case
                                                                                         "FORALL (jj:nat): kk+jj<=pd`qdeg IMPLIES  polynomial(pd`quot, kk+jj) = polynomial(pd`quot, kk)")
                                                                                        (("1"
                                                                                          (inst
                                                                                           -
                                                                                           "pd`qdeg-kk")
                                                                                          (("1"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (induct
                                                                                           "jj")
                                                                                          (("1"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil)
                                                                                           ("2"
                                                                                            (skeep)
                                                                                            (("2"
                                                                                              (assert)
                                                                                              (("2"
                                                                                                (decompose-equality
                                                                                                 1)
                                                                                                (("2"
                                                                                                  (rewrite
                                                                                                   "polynomial_rec"
                                                                                                   1)
                                                                                                  (("2"
                                                                                                    (inst
                                                                                                     -
                                                                                                     "1+j+kk")
                                                                                                    (("2"
                                                                                                      (assert)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (hide
                                                                                 2)
                                                                                (("2"
                                                                                  (skeep
                                                                                   -1)
                                                                                  (("2"
                                                                                    (assert)
                                                                                    (("2"
                                                                                      (name
                                                                                       "IZ"
                                                                                       "{kk:posnat | kk<=pd`qdeg AND pd`quot(kk)/=0}")
                                                                                      (("2"
                                                                                        (name
                                                                                         "M"
                                                                                         "max(IZ)")
                                                                                        (("1"
                                                                                          (typepred
                                                                                           "M")
                                                                                          (("1"
                                                                                            (inst
                                                                                             +
                                                                                             "M")
                                                                                            (("1"
                                                                                              (assert)
                                                                                              (("1"
                                                                                                (copy
                                                                                                 -2)
                                                                                                (("1"
                                                                                                  (expand
                                                                                                   "IZ"
                                                                                                   -1)
                                                                                                  (("1"
                                                                                                    (flatten)
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      (("1"
                                                                                                        (skosimp*)
                                                                                                        (("1"
                                                                                                          (inst
                                                                                                           -
                                                                                                           "ii!1")
                                                                                                          (("1"
                                                                                                            (assert)
                                                                                                            (("1"
                                                                                                              (expand
                                                                                                               "IZ"
                                                                                                               +)
                                                                                                              (("1"
                                                                                                                (propax)
                                                                                                                nil
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil)
                                                                                                           ("2"
                                                                                                            (assert)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (case
                                                                                           "NOT nonempty?[posnat](IZ)")
                                                                                          (("1"
                                                                                            (hide
                                                                                             2)
                                                                                            (("1"
                                                                                              (expand
                                                                                               "nonempty?")
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "empty?")
                                                                                                (("1"
                                                                                                  (inst-cp
                                                                                                   +
                                                                                                   "0")
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    (("1"
                                                                                                      (label
                                                                                                       "IG5"
                                                                                                       -1)
                                                                                                      (("1"
                                                                                                        (copy
                                                                                                         "IG5")
                                                                                                        (("1"
                                                                                                          (hide
                                                                                                           "IG5")
                                                                                                          (("1"
                                                                                                            (inst-cp
                                                                                                             -
                                                                                                             "kk")
                                                                                                            (("1"
                                                                                                              (expand
                                                                                                               "member"
                                                                                                               1)
                                                                                                              (("1"
                                                                                                                (expand
                                                                                                                 "IZ"
                                                                                                                 1)
                                                                                                                (("1"
                                                                                                                  (propax)
                                                                                                                  nil
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil)
                                                                                                             ("2"
                                                                                                              (reveal
                                                                                                               "IG5")
                                                                                                              (("2"
                                                                                                                (delabel
                                                                                                                 "IG5")
                                                                                                                (("2"
                                                                                                                  (assert)
                                                                                                                  (("2"
                                                                                                                    (skosimp*)
                                                                                                                    (("2"
                                                                                                                      (inst
                                                                                                                       -
                                                                                                                       "ii!1")
                                                                                                                      (("2"
                                                                                                                        (expand
                                                                                                                         "member"
                                                                                                                         1)
                                                                                                                        (("2"
                                                                                                                          (expand
                                                                                                                           "IZ"
                                                                                                                           1)
                                                                                                                          (("2"
                                                                                                                            (assert)
                                                                                                                            nil
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (replace
                                                                                             -1)
                                                                                            (("2"
                                                                                              (inst
                                                                                               +
                                                                                               "pd`qdeg+1")
                                                                                              (("2"
                                                                                                (skosimp*)
                                                                                                (("2"
                                                                                                  (typepred
                                                                                                   "y!1")
                                                                                                  (("2"
                                                                                                    (expand
                                                                                                     "IZ"
                                                                                                     -2)
                                                                                                    (("2"
                                                                                                      (ground)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (hide
                                                                             2)
                                                                            (("2"
                                                                              (lemma
                                                                               "poly_eq_0_le_degree")
                                                                              (("2"
                                                                                (inst-cp
                                                                                 -
                                                                                 "pd`quot"
                                                                                 "pd`qdeg")
                                                                                (("2"
                                                                                  (flatten)
                                                                                  (("2"
                                                                                    (hide
                                                                                     -3)
                                                                                    (("2"
                                                                                      (split
                                                                                       -)
                                                                                      (("1"
                                                                                        (inst
                                                                                         -
                                                                                         "p(m-2)"
                                                                                         "n(m-2)")
                                                                                        (("1"
                                                                                          (flatten)
                                                                                          (("1"
                                                                                            (hide
                                                                                             -2)
                                                                                            (("1"
                                                                                              (split
                                                                                               -)
                                                                                              (("1"
                                                                                                (inst
                                                                                                 -
                                                                                                 "n(m-2)")
                                                                                                (("1"
                                                                                                  (assert)
                                                                                                  (("1"
                                                                                                    (inst
                                                                                                     -
                                                                                                     "m-2")
                                                                                                    (("1"
                                                                                                      (inst
                                                                                                       -
                                                                                                       "m-2")
                                                                                                      (("1"
                                                                                                        (inst
                                                                                                         -
                                                                                                         "m-2")
                                                                                                        (("1"
                                                                                                          (inst
                                                                                                           -
                                                                                                           "m-2")
                                                                                                          (("1"
                                                                                                            (assert)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil)
                                                                                               ("2"
                                                                                                (skeep)
                                                                                                (("2"
                                                                                                  (inst
                                                                                                   -7
                                                                                                   "x")
                                                                                                  (("2"
                                                                                                    (inst
                                                                                                     -
                                                                                                     "x")
                                                                                                    (("2"
                                                                                                      (assert)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (skosimp*)
                                                                                        (("2"
                                                                                          (inst
                                                                                           +
                                                                                           "ii!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)
                   ("2" (assert)
                    (("2" (expand "constructed_sturm_sequence?")
                      (("2" (propax) nil nil)) nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (hide (3 4))
              (("2" (induct "k")
                (("1" (assert)
                  (("1" (skeep)
                    (("1" (assert)
                      (("1" (case "NOT i = 0")
                        (("1" (assertnil nil)
                         ("2" (replaces -1)
                          (("2" (assert)
                            (("2" (lift-if)
                              (("2"
                                (split -3)
                                (("1"
                                  (ground)
                                  (("1"
                                    (lemma "root_degree_pos")
                                    (("1"
                                      (inst?)
                                      (("1"
                                        (assert)
                                        (("1"
                                          (copy -6)
                                          (("1"
                                            (expand
                                             "constructed_sturm_sequence?"
                                             -1)
                                            (("1"
                                              (flatten)
                                              (("1"
                                                (replace -3)
                                                (("1"
                                                  (replace -4)
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (rewrite
                                                       "root_degree_mult")
                                                      (("1"
                                                        (rewrite
                                                         "root_degree_deriv")
                                                        (("1"
                                                          (assert)
                                                          nil
                                                          nil)
                                                         ("2"
                                                          (inst - "0")
                                                          nil
                                                          nil)
                                                         ("3"
                                                          (lemma
                                                           "root_degree_pos")
                                                          (("3"
                                                            (inst
                                                             -
                                                             "p(0)"
                                                             "n(0)"
                                                             "y")
                                                            (("3"
                                                              (assert)
                                                              (("3"
                                                                (inst
                                                                 -
                                                                 "0")
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (inst - "0")
                                                        (("2"
                                                          (expand
                                                           "poly_deriv"
                                                           1)
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (ground)
                                                              (("2"
                                                                (mult-by
                                                                 1
                                                                 "n(0)")
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (assert)
                                  (("2"
                                    (flatten)
                                    (("2"
                                      (assert)
                                      (("2"
                                        (expand "max")
                                        (("2"
                                          (lift-if)
                                          (("2"
                                            (split -1)
                                            (("1"
                                              (flatten)
                                              (("1" (assertnil nil))
                                              nil)
                                             ("2"
                                              (flatten)
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (lemma
                                                   "root_degree_pos")
                                                  (("2"
                                                    (inst
                                                     -
                                                     "g"
                                                     "k"
                                                     "y")
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (expand
                                                         "constructed_sturm_sequence?")
                                                        (("2"
                                                          (flatten)
                                                          (("2"
                                                            (replace
                                                             -7)
                                                            (("2"
                                                              (replace
                                                               -6)
                                                              (("2"
                                                                (rewrite
                                                                 "root_degree_mult"
                                                                 +)
                                                                (("1"
                                                                  (rewrite
                                                                   "root_degree_deriv")
                                                                  (("1"
                                                                    (assert)
                                                                    nil
                                                                    nil)
                                                                   ("2"
                                                                    (inst
                                                                     -
                                                                     "0")
                                                                    nil
                                                                    nil)
                                                                   ("3"
                                                                    (lemma
                                                                     "root_degree_pos")
                                                                    (("3"
                                                                      (inst?)
                                                                      (("3"
                                                                        (assert)
                                                                        (("3"
                                                                          (inst
                                                                           -
                                                                           "0")
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (inst
                                                                   -
                                                                   "0")
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (expand
                                                                       "poly_deriv"
                                                                       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)
                 ("2" (skolem 1 "K")
                  (("2" (flatten)
                    (("2" (assert)
                      (("2" (skeep)
                        (("2" (case "NOT i =1+K")
                          (("1" (inst - "i") (("1" (assertnil nil))
                            nil)
                           ("2" (case "NOT K = i-1")
                            (("1" (assertnil nil)
                             ("2" (replace -1)
                              (("2"
                                (assert)
                                (("2"
                                  (hide -2)
                                  (("2"
                                    (inst-cp - "i-1")
                                    (("2"
                                      (assert)
                                      (("2"
                                        (flatten)
                                        (("2"
                                          (copy -9)
                                          (("2"
                                            (expand
                                             "constructed_sturm_sequence?"
                                             -1)
                                            (("2"
                                              (flatten)
                                              (("2"
                                                (hide
                                                 (-1
                                                  -2
                                                  -3
                                                  -4
                                                  -5
                                                  -6
                                                  -7))
                                                (("2"
                                                  (inst - "i+1")
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (skeep)
                                                      (("2"
                                                        (name
                                                         "pd"
                                                         "poly_divide(p(i - 1), n(i - 1))(p(i), n(i))(0)")
                                                        (("2"
                                                          (replace -1)
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (lemma
                                                               "root_degree_eq")
                                                              (("2"
                                                                (lemma
                                                                 "poly_divide_def")
                                                                (("2"
                                                                  (inst?)
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (replace
                                                                       -3)
                                                                      (("2"
                                                                        (split
                                                                         -1)
                                                                        (("1"
                                                                          (lemma
                                                                           "root_degree_division")
                                                                          (("1"
                                                                            (inst
                                                                             -
                                                                             "y"
                                                                             "p(i-1)"
                                                                             "p(i)"
                                                                             "pd`quot"
                                                                             "(1/(-c))*p(1+i)"
                                                                             "n(i-1)"
                                                                             "n(i)"
                                                                             "pd`qdeg"
                                                                             "n(1+i)")
                                                                            (("1"
                                                                              (assert)
                                                                              (("1"
                                                                                (split
                                                                                 -1)
                                                                                (("1"
                                                                                  (flatten)
                                                                                  (("1"
                                                                                    (assert)
                                                                                    (("1"
                                                                                      (split
                                                                                       -9)
                                                                                      (("1"
                                                                                        (assert)
                                                                                        (("1"
                                                                                          (case
                                                                                           "root_degree(p(i), n(i))(y) = dd")
                                                                                          (("1"
                                                                                            (assert)
                                                                                            (("1"
                                                                                              (expand
                                                                                               "min")
                                                                                              (("1"
                                                                                                (assert)
                                                                                                (("1"
                                                                                                  (rewrite
                                                                                                   "root_degree_scal")
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    nil
                                                                                                    nil)
                                                                                                   ("2"
                                                                                                    (copy
                                                                                                     "css")
                                                                                                    (("2"
                                                                                                      (expand
                                                                                                       "constructed_sturm_sequence?"
                                                                                                       -1)
                                                                                                      (("2"
                                                                                                        (flatten)
                                                                                                        (("2"
                                                                                                          (inst
                                                                                                           -
                                                                                                           "i+1")
                                                                                                          (("2"
                                                                                                            (assert)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (assert)
                                                                                            (("2"
                                                                                              (assert)
                                                                                              (("2"
                                                                                                (rewrite
                                                                                                 "root_degree_scal")
                                                                                                (("1"
                                                                                                  (assert)
                                                                                                  nil
                                                                                                  nil)
                                                                                                 ("2"
                                                                                                  (copy
                                                                                                   "css")
                                                                                                  (("2"
                                                                                                    (expand
                                                                                                     "constructed_sturm_sequence?"
                                                                                                     -1)
                                                                                                    (("2"
                                                                                                      (flatten)
                                                                                                      (("2"
                                                                                                        (inst
                                                                                                         -
                                                                                                         "1+i")
                                                                                                        (("2"
                                                                                                          (assert)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (assert)
                                                                                        (("2"
                                                                                          (rewrite
                                                                                           "root_degree_scal")
                                                                                          (("1"
                                                                                            (expand
                                                                                             "min")
                                                                                            (("1"
                                                                                              (assert)
                                                                                              (("1"
                                                                                                (lift-if)
                                                                                                (("1"
                                                                                                  (ground)
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (copy
                                                                                             "css")
                                                                                            (("2"
                                                                                              (expand
                                                                                               "constructed_sturm_sequence?"
                                                                                               -1)
                                                                                              (("2"
                                                                                                (flatten)
                                                                                                (("2"
                                                                                                  (inst
                                                                                                   -
                                                                                                   "1+i")
                                                                                                  (("2"
                                                                                                    (assert)
                                                                                                    nil
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (hide
                                                                                   2)
                                                                                  (("2"
                                                                                    (skeep)
                                                                                    (("2"
                                                                                      (inst
                                                                                       -
                                                                                       "x")
                                                                                      (("2"
                                                                                        (replace
                                                                                         -1)
                                                                                        (("2"
                                                                                          (assert)
                                                                                          (("2"
                                                                                            (decompose-equality
                                                                                             -4)
                                                                                            (("2"
                                                                                              (assert)
                                                                                              (("2"
                                                                                                (inst
                                                                                                 -
                                                                                                 "x")
                                                                                                (("2"
                                                                                                  (assert)
                                                                                                  (("2"
                                                                                                    (rewrite
                                                                                                     "scal_polynomial2")
                                                                                                    (("2"
                                                                                                      (rewrite
                                                                                                       "scal_polynomial2")
                                                                                                      (("2"
                                                                                                        (assert)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil)
                                                                                 ("3"
                                                                                  (copy
                                                                                   "css")
                                                                                  (("3"
                                                                                    (expand
                                                                                     "constructed_sturm_sequence?"
                                                                                     -1)
                                                                                    (("3"
                                                                                      (expand
                                                                                       "*"
                                                                                       1)
                                                                                      (("3"
                                                                                        (flatten)
                                                                                        (("3"
                                                                                          (inst
                                                                                           -
                                                                                           "1+i")
                                                                                          (("3"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil)
                                                                                 ("4"
                                                                                  (copy
                                                                                   "css")
                                                                                  (("4"
                                                                                    (expand
                                                                                     "constructed_sturm_sequence?"
                                                                                     -1)
                                                                                    (("4"
                                                                                      (flatten)
                                                                                      (("4"
                                                                                        (inst
                                                                                         -
                                                                                         "i-1")
                                                                                        (("4"
                                                                                          (assert)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil)
                                                                                 ("5"
                                                                                  (copy
                                                                                   "css")
                                                                                  (("5"
                                                                                    (expand
                                                                                     "constructed_sturm_sequence?"
                                                                                     -1)
                                                                                    (("5"
                                                                                      (flatten)
                                                                                      (("5"
                                                                                        (inst
                                                                                         -
                                                                                         "i")
                                                                                        (("5"
                                                                                          (assert)
                                                                                          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))
                                                                        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)
   ((max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (root_degree def-decl "{m |
         m <= n AND
          (a(n) /= 0 IMPLIES
            ((EXISTS (b: [nat -> real]):
                (FORALL (x):
                   polynomial(a, n)(x) =
                    (x - y) ^ m * polynomial(b, n - m)(x))
                 AND polynomial(b, n - m)(y) /= 0 AND b(n - m) /= 0)
              AND
              (polynomial(a, n)(y) = 0 IMPLIES m > 0) AND
               ((n > 0 AND m > 0) IMPLIES
                 (EXISTS (q: [nat -> real]):
                    (FORALL (x):
                       polynomial(poly_deriv(a), n - 1)(x) =
                        (x - y) ^ (m - 1) * polynomial(q, n - m)(x))
                     AND polynomial(q, n - m)(y) /= 0))))}"
     more_polynomial_props "reals/")
    (poly_deriv const-decl "real" polynomials "reals/")
    (> const-decl "bool" reals nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (^ const-decl "real" exponentiation nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (/= const-decl "boolean" notequal nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (polynomial const-decl "[real -> real]" polynomials "reals/")
    (sequence type-eq-decl nil sequences nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (rat_max application-judgement "{s: rat | s >= q AND s >= r}"
     real_defs nil)
    (int_max application-judgement "{k: int | i <= k AND j <= k}"
     real_defs nil)
    (root_degree_eq formula-decl nil more_polynomial_props "reals/")
    (root_degree_division formula-decl nil more_polynomial_props
     "reals/")
    (min const-decl "{p: real | p <= m AND p <= n}" real_defs nil)
    (root_degree_scal formula-decl nil more_polynomial_props "reals/")
    (nat_min application-judgement "{k: nat | k <= i AND k <= j}"
     real_defs nil)
    (* const-decl "[T -> real]" real_fun_ops "reals/")
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (nzreal_div_nzreal_is_nzreal application-judgement "nzreal"
     real_types nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (m skolem-const-decl "posnat" sturmtarski nil)
    (i skolem-const-decl "nat" sturmtarski nil)
    (max_npreal_0 formula-decl nil min_max "reals/")
    (both_sides_times1 formula-decl nil real_props nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (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)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (root_degree_mult formula-decl nil more_polynomial_props "reals/")
    (real_times_real_is_real application-judgement "real" reals nil)
    (sigma def-decl "real" sigma "reals/")
    (polynomial_prod const-decl "real" polynomials "reals/")
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (root_degree_deriv formula-decl nil more_polynomial_props "reals/")
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (below type-eq-decl nil naturalnumbers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (default_root_degree? const-decl "bool" sturmtarski nil)
    (root_degree_pos formula-decl nil more_polynomial_props "reals/")
    (DivType type-eq-decl nil polynomial_division "Sturm/")
    (poly_divide def-decl "DivType" polynomial_division "Sturm/")
    (poly_divide_def formula-decl nil polynomial_division "Sturm/")
    (- 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)
    (scal_polynomial2 formula-decl nil polynomials "reals/")
    (pred type-eq-decl nil defined_types nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (polynomial_rec formula-decl nil polynomials "reals/")
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (ii!1 skolem-const-decl "nat" sturmtarski nil)
    (member const-decl "bool" sets nil)
    (kk skolem-const-decl "nat" sturmtarski nil)
    (empty? const-decl "bool" sets nil)
    (IZ skolem-const-decl "[posnat -> boolean]" sturmtarski nil)
    (ii!1 skolem-const-decl "nat" sturmtarski nil)
    (max const-decl
         "{a: posnat | S(a) AND (FORALL x: S(x) IMPLIES x <= a)}"
         max_bounded_posnat "ints/")
    (nonempty? const-decl "bool" sets nil)
    (set type-eq-decl nil sets nil)
    (poly_eq_0_le_degree formula-decl nil polynomials "reals/")
    (root_degree_lower_bound formula-decl nil more_polynomial_props
     "reals/")
    (real_minus_real_is_real application-judgement "real" reals nil)
    (polynomial_prod_def formula-decl nil polynomials "reals/")
    (newprod skolem-const-decl "[nat -> real]" sturmtarski nil)
    (minus_nzreal_is_nzreal application-judgement "nzreal" real_types
     nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (< const-decl "bool" reals nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (constructed_sturm_sequence? const-decl "bool" sturmtarski nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil))
   nil)
  (constructed_sturm_seq_root_degrees-1 nil 3617013924
   ("" (skeep)
    (("" (case "g(k)=0")
      (("1" (expand "constructed_sturm_sequence?")
        (("1" (ground) nil nil)) nil)
       ("2"
        (name "dd"
              "IF polynomial(g,k)(y)=0 THEN root_degree(p(0),n(0))(y) ELSE max(root_degree(p(0), n(0))(y) - 1, 0) ENDIF")
        (("2"
          (case "FORALL (k,i:nat): i<=k AND k+1<m IMPLIES ((root_degree(p(i),n(i))(y)=dd OR root_degree(p(i+1),n(i+1))(y)=dd) AND (root_degree(p(i),n(i))(y)>=dd AND root_degree(p(i+1),n(i+1))(y)>=dd))")
          (("1" (assert)
            (("1" (inst - "m-2" _)
              (("1" (assert)
                (("1" (lift-if)
                  (("1" (split -)
                    (("1" (flatten)
                      (("1" (lemma "root_degree_pos")
                        (("1" (inst?)
                          (("1" (assert)
                            (("1" (hide 3)
                              (("1"
                                (expand "default_root_degree?")
                                (("1"
                                  (assert)
                                  (("1"
                                    (invoke (case "NOT (%1)") (! 2 1))
                                    (("1"
                                      (hide 3)
                                      (("1"
                                        (copy -5)
                                        (("1"
                                          (expand
                                           "constructed_sturm_sequence?"
                                           -1)
                                          (("1"
                                            (flatten)
                                            (("1"
                                              (assert)
                                              (("1"
                                                (replace -4 +)
                                                (("1"
                                                  (lemma
                                                   "root_degree_mult")
                                                  (("1"
                                                    (inst?)
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (inst - "y")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (split -1)
                                                            (("1"
                                                              (replace
                                                               -6)
                                                              (("1"
                                                                (replaces
                                                                 -1)
                                                                (("1"
                                                                  (rewrite
                                                                   "root_degree_deriv")
                                                                  (("1"
                                                                    (ground)
                                                                    nil
                                                                    nil)
                                                                   ("2"
                                                                    (inst
                                                                     -
                                                                     "0")
                                                                    nil
                                                                    nil)
                                                                   ("3"
                                                                    (lemma
                                                                     "root_degree_pos")
                                                                    (("3"
                                                                      (inst?)
                                                                      (("3"
                                                                        (assert)
                                                                        (("3"
                                                                          (inst
                                                                           -
                                                                           "0")
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (inst
                                                               -
                                                               "1")
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (replace
                                                                   -5)
                                                                  (("2"
                                                                    (replace
                                                                     -4
                                                                     -1)
                                                                    (("2"
                                                                      (flatten)
                                                                      (("2"
                                                                        (expand
                                                                         "polynomial_prod"
                                                                         1)
                                                                        (("2"
                                                                          (expand
                                                                           "max"
                                                                           1)
                                                                          (("2"
                                                                            (expand
                                                                             "sigma"
                                                                             1)
                                                                            (("2"
                                                                              (expand
                                                                               "sigma"
                                                                               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"
                                      (replace -1)
                                      (("2"
                                        (skeep)
                                        (("2"
                                          (replace -4)
                                          (("2"
                                            (assert)
                                            (("2"
                                              (inst-cp - "i-1")
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (flatten)
                                                  (("2"
                                                    (inst-cp - "i")
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (ground)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (flatten)
                      (("2" (assert)
                        (("2" (hide 3)
                          (("2" (replace -1)
                            (("2" (expand "default_root_degree?")
                              (("2"
                                (invoke (case "NOT (%1)") (! 3 1))
                                (("1"
                                  (hide 4)
                                  (("1"
                                    (assert)
                                    (("1"
                                      (flatten)
                                      (("1"
                                        (assert)
                                        (("1"
                                          (case
                                           "polynomial(p(0),n(0))(y)/=0")
                                          (("1"
                                            (flatten)
                                            (("1"
                                              (assert)
                                              (("1"
                                                (lemma
                                                 "root_degree_pos")
                                                (("1"
                                                  (inst?)
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (copy -4)
                                                      (("1"
                                                        (split -)
                                                        (("1"
                                                          (assert)
                                                          nil
                                                          nil)
                                                         ("2"
                                                          (expand
                                                           "constructed_sturm_sequence?")
                                                          (("2"
                                                            (flatten)
                                                            (("2"
                                                              (inst
                                                               -
                                                               "0")
                                                              (("2"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (assert)
                                            (("2"
                                              (hide 2)
                                              (("2"
                                                (lemma
                                                 "root_degree_pos")
                                                (("2"
                                                  (inst?)
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (lemma
                                                       "root_degree_pos")
                                                      (("2"
                                                        (inst
                                                         -
                                                         "p(0)"
                                                         "n(0)"
                                                         "y")
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (split -1)
                                                            (("1"
                                                              (expand
                                                               "max"
                                                               -2)
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (copy
                                                                     -4)
                                                                    (("1"
                                                                      (expand
                                                                       "constructed_sturm_sequence?"
                                                                       -1)
                                                                      (("1"
                                                                        (flatten)
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (replace
                                                                             -4)
                                                                            (("1"
                                                                              (replace
                                                                               -3)
                                                                              (("1"
                                                                                (rewrite
                                                                                 "root_degree_mult")
                                                                                (("1"
                                                                                  (rewrite
                                                                                   "root_degree_deriv")
                                                                                  (("1"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil)
                                                                                   ("2"
                                                                                    (inst
                                                                                     -
                                                                                     "0")
                                                                                    nil
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (inst
                                                                                   -
                                                                                   "0")
                                                                                  (("2"
                                                                                    (expand
                                                                                     "poly_deriv"
                                                                                     1)
                                                                                    (("2"
                                                                                      (assert)
                                                                                      (("2"
                                                                                        (ground)
                                                                                        (("2"
                                                                                          (mult-by
                                                                                           1
                                                                                           "n(0)")
                                                                                          (("2"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (expand
                                                               "constructed_sturm_sequence?")
                                                              (("2"
                                                                (flatten)
                                                                (("2"
                                                                  (inst
                                                                   -5
                                                                   "0")
                                                                  (("2"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (replace -1)
                                  (("2"
                                    (assert)
                                    (("2"
                                      (hide -1)
                                      (("2"
                                        (skeep)
                                        (("2"
                                          (assert)
                                          (("2"
                                            (split +)
                                            (("1"
                                              (flatten)
                                              (("1"
                                                (inst - "i-1")
                                                (("1" (assertnil nil)
                                                 ("2"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (flatten)
                                              (("2"
                                                (inst - "i")
                                                (("2"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (expand "constructed_sturm_sequence?")
                (("2" (assertnil nil)) nil))
              nil))
            nil)
           ("2" (hide (3 4))
            (("2" (induct "k")
              (("1" (assert)
                (("1" (skeep)
                  (("1" (assert)
                    (("1" (case "NOT i = 0")
                      (("1" (assertnil nil)
                       ("2" (replaces -1)
                        (("2" (assert)
                          (("2" (lift-if)
                            (("2" (split -3)
                              (("1"
                                (ground)
                                (("1"
                                  (lemma "root_degree_pos")
                                  (("1"
                                    (inst?)
                                    (("1"
                                      (assert)
                                      (("1"
                                        (copy -6)
                                        (("1"
                                          (expand
                                           "constructed_sturm_sequence?"
                                           -1)
                                          (("1"
                                            (flatten)
                                            (("1"
                                              (replace -3)
                                              (("1"
                                                (replace -4)
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (rewrite
                                                     "root_degree_mult")
                                                    (("1"
                                                      (rewrite
                                                       "root_degree_deriv")
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil)
                                                       ("2"
                                                        (inst - "0")
                                                        nil
                                                        nil)
                                                       ("3"
                                                        (lemma
                                                         "root_degree_pos")
                                                        (("3"
                                                          (inst
                                                           -
                                                           "p(0)"
                                                           "n(0)"
                                                           "y")
                                                          (("3"
                                                            (assert)
                                                            (("3"
                                                              (inst
                                                               -
                                                               "0")
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (inst - "0")
                                                      (("2"
                                                        (expand
                                                         "poly_deriv"
                                                         1)
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (ground)
                                                            (("2"
                                                              (mult-by
                                                               1
                                                               "n(0)")
                                                              (("2"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (assert)
                                (("2"
                                  (flatten)
                                  (("2"
                                    (assert)
                                    (("2"
                                      (expand "max")
                                      (("2"
                                        (lift-if)
                                        (("2"
                                          (split -1)
                                          (("1"
                                            (flatten)
                                            (("1" (assertnil nil))
                                            nil)
                                           ("2"
                                            (flatten)
                                            (("2"
                                              (assert)
                                              (("2"
                                                (lemma
                                                 "root_degree_pos")
                                                (("2"
                                                  (inst - "g" "k" "y")
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (expand
                                                       "constructed_sturm_sequence?")
                                                      (("2"
                                                        (flatten)
                                                        (("2"
                                                          (replace -7)
                                                          (("2"
                                                            (replace
                                                             -6)
                                                            (("2"
                                                              (rewrite
                                                               "root_degree_mult"
                                                               +)
                                                              (("1"
                                                                (rewrite
                                                                 "root_degree_deriv")
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil)
                                                                 ("2"
                                                                  (inst
                                                                   -
                                                                   "0")
                                                                  nil
                                                                  nil)
                                                                 ("3"
                                                                  (lemma
                                                                   "root_degree_pos")
                                                                  (("3"
                                                                    (inst?)
                                                                    (("3"
                                                                      (assert)
                                                                      (("3"
                                                                        (inst
                                                                         -
                                                                         "0")
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (inst
                                                                 -
                                                                 "0")
                                                                (("2"
                                                                  (assert)
                                                                  (("2"
                                                                    (expand
                                                                     "poly_deriv"
                                                                     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)
               ("2" (skolem 1 "K")
                (("2" (flatten)
                  (("2" (assert)
                    (("2" (skeep)
                      (("2" (case "NOT i =1+K")
                        (("1" (inst - "i") (("1" (assertnil nil))
                          nil)
                         ("2" (case "NOT K = i-1")
                          (("1" (assertnil nil)
                           ("2" (replace -1)
                            (("2" (assert)
                              (("2"
                                (hide -2)
                                (("2"
                                  (inst-cp - "i-1")
                                  (("2"
                                    (assert)
                                    (("2"
                                      (flatten)
                                      (("2"
                                        (copy -9)
                                        (("2"
                                          (expand
                                           "constructed_sturm_sequence?"
                                           -1)
                                          (("2"
                                            (flatten)
                                            (("2"
                                              (hide
                                               (-1 -2 -3 -4 -5 -6 -7))
                                              (("2"
                                                (inst - "i+1")
                                                (("2"
                                                  (assert)
                                                  (("2"
                                                    (skeep)
                                                    (("2"
                                                      (name
                                                       "pd"
                                                       "poly_divide(p(i - 1), n(i - 1))(p(i), n(i))(0)")
                                                      (("2"
                                                        (replace -1)
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (lemma
                                                             "root_degree_eq")
                                                            (("2"
                                                              (lemma
                                                               "poly_divide_def")
                                                              (("2"
                                                                (inst?)
                                                                (("2"
                                                                  (assert)
                                                                  (("2"
                                                                    (replace
                                                                     -3)
                                                                    (("2"
                                                                      (split
                                                                       -1)
                                                                      (("1"
                                                                        (lemma
                                                                         "root_degree_division")
                                                                        (("1"
                                                                          (inst
                                                                           -
                                                                           "y"
                                                                           "p(i-1)"
                                                                           "p(i)"
                                                                           "pd`quot"
                                                                           "(1/(-c))*p(1+i)"
                                                                           "n(i-1)"
                                                                           "n(i)"
                                                                           "pd`qdeg"
                                                                           "n(1+i)")
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (split
                                                                               -1)
                                                                              (("1"
                                                                                (flatten)
                                                                                (("1"
                                                                                  (assert)
                                                                                  (("1"
                                                                                    (split
                                                                                     -9)
                                                                                    (("1"
                                                                                      (assert)
                                                                                      (("1"
                                                                                        (case
                                                                                         "root_degree(p(i), n(i))(y) = dd")
                                                                                        (("1"
                                                                                          (assert)
                                                                                          (("1"
                                                                                            (expand
                                                                                             "min")
                                                                                            (("1"
                                                                                              (assert)
                                                                                              (("1"
                                                                                                (rewrite
                                                                                                 "root_degree_scal")
                                                                                                (("1"
                                                                                                  (assert)
                                                                                                  nil
                                                                                                  nil)
                                                                                                 ("2"
                                                                                                  (postpone)
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (postpone)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (postpone)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (postpone)
                                                                                nil
                                                                                nil)
                                                                               ("3"
                                                                                (postpone)
                                                                                nil
                                                                                nil)
                                                                               ("4"
                                                                                (postpone)
                                                                                nil
                                                                                nil)
                                                                               ("5"
                                                                                (postpone)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (postpone)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   nil shostak))
 (default_root_deg_TCC1 0
  (default_root_deg_TCC1-1 nil 3617953557 ("" (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)
    (rat_max application-judgement "{s: rat | s >= q AND s >= r}"
     real_defs nil)
    (int_max application-judgement "{k: int | i <= k AND j <= k}"
     real_defs 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_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (^ const-decl "real" exponentiation nil)
    (polynomial const-decl "[real -> real]" polynomials "reals/")
    (real_times_real_is_real application-judgement "real" reals nil)
    (int_minus_int_is_int application-judgement "int" integers nil))
   nil))
 (default_root_deg_def 0
  (default_root_deg_def-1 nil 3617953558
   ("" (skeep)
    (("" (lemma "constructed_sturm_seq_root_degrees")
      (("" (inst?)
        (("" (assert)
          (("" (expand "default_root_deg") (("" (ground) nil nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((constructed_sturm_seq_root_degrees formula-decl nil sturmtarski
     nil)
    (rat_max application-judgement "{s: rat | s >= q AND s >= r}"
     real_defs nil)
    (int_max application-judgement "{k: int | i <= k AND j <= k}"
     real_defs nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (default_root_deg const-decl "nat" sturmtarski nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (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))
   shostak))
 (constructed_sturm_seq_root_degree_lower_bound 0
  (constructed_sturm_seq_root_degree_lower_bound-1 nil 3618047247
   (""
    (case "FORALL (g: [nat -> real], k: nat, m: posnat, n: [nat -> nat],
              p: [nat -> [nat -> real]], y: real,dd:nat):
        constructed_sturm_sequence?(p, n, g, k, m) AND dd<m IMPLIES
         (FORALL (i):
            i <= dd IMPLIES
             root_degree(p(i), n(i))(y) >=
              default_root_deg(p, n, g, k, m)(y))")
    (("1" (skeep)
      (("1" (inst?)
        (("1" (inst - "m-1")
          (("1" (assert)
            (("1" (skeep)
              (("1" (inst - "i") (("1" (assertnil nil)) nil)) nil))
            nil))
          nil))
        nil))
      nil)
     ("2" (hide 2)
      (("2" (induct "dd")
        (("1" (skeep)
          (("1" (skeep)
            (("1" (case "NOT i = 0")
              (("1" (assertnil nil)
               ("2" (replace -1)
                (("2" (assert)
                  (("2" (expand "default_root_deg" 1)
                    (("2" (expand "max")
                      (("2" (lift-if) (("2" (ground) nil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (skeep)
          (("2" (skeep)
            (("2" (skeep)
              (("2" (case "NOT i = j+1")
                (("1" (inst - "g" "k" "m" "n" "p" "y")
                  (("1" (assert)
                    (("1" (inst - "i") (("1" (assertnil nil)) nil))
                    nil))
                  nil)
                 ("2" (hide -5)
                  (("2" (replace -1)
                    (("2" (assert)
                      (("2" (case "j = 0")
                        (("1" (replace -1)
                          (("1" (assert)
                            (("1" (expand "default_root_deg" 1)
                              (("1"
                                (copy -4)
                                (("1"
                                  (expand "max")
                                  (("1"
                                    (lift-if)
                                    (("1"
                                      (ground)
                                      (("1"
                                        (expand
                                         "constructed_sturm_sequence?"
                                         -2)
                                        (("1"
                                          (flatten)
                                          (("1"
                                            (replace -4)
                                            (("1"
                                              (replace -5)
                                              (("1"
                                                (rewrite
                                                 "root_degree_mult")
                                                (("1"
                                                  (rewrite
                                                   "root_degree_deriv")
                                                  (("1"
                                                    (lemma
                                                     "root_degree_pos")
                                                    (("1"
                                                      (inst?)
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (inst - "0")
                                                    nil
                                                    nil)
                                                   ("3"
                                                    (lemma
                                                     "root_degree_pos")
                                                    (("3"
                                                      (inst
                                                       -
                                                       "p(0)"
                                                       "n(0)"
                                                       "y")
                                                      (("3"
                                                        (assert)
                                                        (("3"
                                                          (inst - "0")
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (expand
                                                   "poly_deriv"
                                                   1)
                                                  (("2"
                                                    (inst - "0")
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (ground)
                                                        (("2"
                                                          (mult-by
                                                           2
                                                           "n(0)")
                                                          (("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (expand
                                         "constructed_sturm_sequence?"
                                         -1)
                                        (("2"
                                          (flatten)
                                          (("2"
                                            (inst-cp - "0")
                                            (("2"
                                              (inst - "1")
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (flatten)
                                                  (("2"
                                                    (replace -2 2)
                                                    (("2"
                                                      (replace -3 2)
                                                      (("2"
                                                        (rewrite
                                                         "root_degree_mult")
                                                        (("1"
                                                          (rewrite
                                                           "root_degree_deriv")
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil)
                                                           ("2"
                                                            (lemma
                                                             "root_degree_pos")
                                                            (("2"
                                                              (inst
                                                               -
                                                               "p(0)"
                                                               "n(0)"
                                                               "y")
                                                              (("2"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (expand
                                                           "poly_deriv"
                                                           1)
                                                          (("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (copy -3)
                          (("2" (label "igz" -1)
                            (("2"
                              (case "NOT (p(1+j)(n(1+j))/=0 AND p(j)(n(j))/=0 AND p(j-1)(n(j-1))/=0)")
                              (("1"
                                (expand
                                 "constructed_sturm_sequence?"
                                 -1)
                                (("1"
                                  (flatten)
                                  (("1"
                                    (inst-cp - "1+j")
                                    (("1"
                                      (inst-cp - "j")
                                      (("1"
                                        (inst - "j-1")
                                        (("1" (assertnil nil)
                                         ("2" (assertnil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (flatten)
                                (("2"
                                  (assert)
                                  (("2"
                                    (expand
                                     "constructed_sturm_sequence?"
                                     -1)
                                    (("2"
                                      (flatten)
                                      (("2"
                                        (copy -8)
                                        (("2"
                                          (hide "igz")
                                          (("2"
                                            (inst - "j+1")
                                            (("2"
                                              (assert)
                                              (("2"
                                                (skeep)
                                                (("2"
                                                  (name
                                                   "pd"
                                                   "poly_divide(p(j - 1), n(j - 1))(p(j), n(j))(0)")
                                                  (("2"
                                                    (replace -1)
                                                    (("2"
                                                      (case
                                                       "NOT polynomial((-1/c)*p(1 + j), n(1 + j)) = polynomial(pd`rem, pd`rdeg)")
                                                      (("1"
                                                        (decompose-equality
                                                         1)
                                                        (("1"
                                                          (rewrite
                                                           "scal_polynomial2")
                                                          (("1"
                                                            (decompose-equality
                                                             -2)
                                                            (("1"
                                                              (inst
                                                               -
                                                               "x!1")
                                                              (("1"
                                                                (rewrite
                                                                 "scal_polynomial2")
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (lemma
                                                         "poly_divide_def")
                                                        (("2"
                                                          (inst?)
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (replace
                                                               -3)
                                                              (("2"
                                                                (replace
                                                                 -2
                                                                 :dir
                                                                 rl)
                                                                (("2"
                                                                  (lemma
                                                                   "root_degree_division")
                                                                  (("2"
                                                                    (inst
                                                                     -
                                                                     "y"
                                                                     "p(j - 1)"
                                                                     "p(j)"
                                                                     "pd`quot"
                                                                     "(-1/c)*p(1+j)"
                                                                     "n(j-1)"
                                                                     "n(j)"
                                                                     "pd`qdeg"
                                                                     "n(1+j)")
                                                                    (("2"
                                                                      (assert)
                                                                      (("2"
                                                                        (replace
                                                                         -2)
                                                                        (("2"
                                                                          (split
                                                                           -1)
                                                                          (("1"
                                                                            (flatten)
                                                                            (("1"
                                                                              (inst?
                                                                               -8)
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (copy
                                                                                   -8)
                                                                                  (("1"
                                                                                    (inst-cp
                                                                                     -
                                                                                     "j-1")
                                                                                    (("1"
                                                                                      (inst
                                                                                       -
                                                                                       "j")
                                                                                      (("1"
                                                                                        (assert)
                                                                                        (("1"
                                                                                          (expand
                                                                                           "min")
                                                                                          (("1"
                                                                                            (lift-if)
                                                                                            (("1"
                                                                                              (hide
                                                                                               -3)
                                                                                              (("1"
                                                                                                (split
                                                                                                 -)
                                                                                                (("1"
                                                                                                  (flatten)
                                                                                                  (("1"
                                                                                                    (rewrite
                                                                                                     "root_degree_scal")
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil)
                                                                                                 ("2"
                                                                                                  (flatten)
                                                                                                  (("2"
                                                                                                    (rewrite
                                                                                                     "root_degree_scal")
                                                                                                    (("2"
                                                                                                      (assert)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (expand
                                                                             "*"
                                                                             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)
                               ("3" (ground) nil nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((j skolem-const-decl "nat" sturmtarski nil)
    (DivType type-eq-decl nil polynomial_division "Sturm/")
    (poly_divide def-decl "DivType" polynomial_division "Sturm/")
    (nzreal_div_nzreal_is_nzreal application-judgement "nzreal"
     real_types nil)
    (* const-decl "[T -> real]" real_fun_ops "reals/")
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields 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)
    (scal_polynomial2 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)
    (root_degree_division formula-decl nil more_polynomial_props
     "reals/")
    (min const-decl "{p: real | p <= m AND p <= n}" real_defs nil)
    (root_degree_scal formula-decl nil more_polynomial_props "reals/")
    (nat_min application-judgement "{k: nat | k <= i AND k <= j}"
     real_defs nil)
    (poly_divide_def formula-decl nil polynomial_division "Sturm/")
    (real_times_real_is_real application-judgement "real" reals nil)
    (both_sides_times1 formula-decl nil real_props nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (root_degree_deriv formula-decl nil more_polynomial_props "reals/")
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (root_degree_pos formula-decl nil more_polynomial_props "reals/")
    (below type-eq-decl nil naturalnumbers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (root_degree_mult formula-decl nil more_polynomial_props "reals/")
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs 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)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (constructed_sturm_sequence? const-decl "bool" sturmtarski nil)
    (< const-decl "bool" reals nil) (<= const-decl "bool" reals nil)
    (sequence type-eq-decl nil sequences nil)
    (/= const-decl "boolean" notequal nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (polynomial const-decl "[real -> real]" polynomials "reals/")
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (^ const-decl "real" exponentiation nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (poly_deriv const-decl "real" polynomials "reals/")
    (root_degree def-decl "{m |
         m <= n AND
          (a(n) /= 0 IMPLIES
            ((EXISTS (b: [nat -> real]):
                (FORALL (x):
                   polynomial(a, n)(x) =
                    (x - y) ^ m * polynomial(b, n - m)(x))
                 AND polynomial(b, n - m)(y) /= 0 AND b(n - m) /= 0)
              AND
              (polynomial(a, n)(y) = 0 IMPLIES m > 0) AND
               ((n > 0 AND m > 0) IMPLIES
                 (EXISTS (q: [nat -> real]):
                    (FORALL (x):
                       polynomial(poly_deriv(a), n - 1)(x) =
                        (x - y) ^ (m - 1) * polynomial(q, n - m)(x))
                     AND polynomial(q, n - m)(y) /= 0))))}"
     more_polynomial_props "reals/")
    (default_root_deg const-decl "nat" sturmtarski nil))
   shostak))
 (sturm_tarski_basic_1 0
  (sturm_tarski_basic_1-5 nil 3617696203
   ("" (skeep)
    (("" (label "css" -1)
      (("" (label "igz" -2)
        ((""
          (case "FORALL (xy,xr:real): x<=xy AND xy<=xr AND xr<=y IMPLIES sign_ext(polynomial(g,k)(xy)) = sign_ext(polynomial(g,k)(xr))")
          (("1" (inst-cp - "x" "z")
            (("1" (inst - "z" "y")
              (("1" (assert)
                (("1" (case "x<=z AND z<=y")
                  (("1" (flatten)
                    (("1" (assert)
                      (("1" (hide (-1 -2))
                        (("1" (case "m>=2")
                          (("1" (inst-cp - "0")
                            (("1" (inst - "1")
                              (("1"
                                (assert)
                                (("1"
                                  (expand "only_root_between?")
                                  (("1"
                                    (flatten)
                                    (("1"
                                      (hide (-5 -6))
                                      (("1"
                                        (assert)
                                        (("1"
                                          (inst-cp - "x")
                                          (("1"
                                            (inst - "y")
                                            (("1"
                                              (assert)
                                              (("1"
                                                (inst-cp - "x")
                                                (("1"
                                                  (inst - "y")
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (flatten)
                                                      (("1"
                                                        (expand
                                                         "number_sign_changes")
                                                        (("1"
                                                          (expand
                                                           "number_sign_changes")
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (lift-if)
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (lift-if)
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (lift-if)
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (case
                                                                           "sign_ext(polynomial(poly_deriv(p(0)), n(0)-1)(x)) =
                                                                                                       -sign_ext(polynomial(p(0), n(0))(x))")
                                                                          (("1"
                                                                            (case
                                                                             "sign_ext(polynomial(p(0),n(0))(x)) = -sign_ext(polynomial(g,k)(x))*sign_ext(polynomial(p(1),n(1))(x))")
                                                                            (("1"
                                                                              (hide
                                                                               -2)
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (lemma
                                                                                   "root_degree_pos")
                                                                                  (("1"
                                                                                    (lemma
                                                                                     "root_degree_pos")
                                                                                    (("1"
                                                                                      (inst-cp
                                                                                       -
                                                                                       "p(0)"
                                                                                       "n(0)"
                                                                                       "z")
                                                                                      (("1"
                                                                                        (assert)
                                                                                        (("1"
                                                                                          (inst
                                                                                           -
                                                                                           "g"
                                                                                           "k"
                                                                                           "z")
                                                                                          (("1"
                                                                                            (assert)
                                                                                            (("1"
                                                                                              (case
                                                                                               "NOT (p(0)(n(0))/=0 AND g(k)/=0)")
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "constructed_sturm_sequence?")
                                                                                                (("1"
                                                                                                  (flatten)
                                                                                                  (("1"
                                                                                                    (inst
                                                                                                     -
                                                                                                     "0")
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil)
                                                                                               ("2"
                                                                                                (flatten)
                                                                                                (("2"
                                                                                                  (assert)
                                                                                                  (("2"
                                                                                                    (name
                                                                                                     "dd"
                                                                                                     "root_degree(p(0),n(0))(z)")
                                                                                                    (("2"
                                                                                                      (replace
                                                                                                       -1)
                                                                                                      (("2"
                                                                                                        (case
                                                                                                         "root_degree(p(1),n(1))(z) = dd-1")
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          (("1"
                                                                                                            (lemma
                                                                                                             "even_or_odd")
                                                                                                            (("1"
                                                                                                              (inst-cp
                                                                                                               -
                                                                                                               "dd")
                                                                                                              (("1"
                                                                                                                (inst
                                                                                                                 -
                                                                                                                 "dd-1")
                                                                                                                (("1"
                                                                                                                  (lemma
                                                                                                                   "odd_iff_even_succ")
                                                                                                                  (("1"
                                                                                                                    (inst
                                                                                                                     -
                                                                                                                     "dd-1")
                                                                                                                    (("1"
                                                                                                                      (assert)
                                                                                                                      (("1"
                                                                                                                        (lemma
                                                                                                                         "root_degree_even")
                                                                                                                        (("1"
                                                                                                                          (inst-cp
                                                                                                                           -
                                                                                                                           "p(0)"
                                                                                                                           "n(0)"
                                                                                                                           "x"
                                                                                                                           "y"
                                                                                                                           "z")
                                                                                                                          (("1"
                                                                                                                            (assert)
                                                                                                                            (("1"
                                                                                                                              (inst
                                                                                                                               -
                                                                                                                               "p(1)"
                                                                                                                               "n(1)"
                                                                                                                               "x"
                                                                                                                               "y"
                                                                                                                               "z")
                                                                                                                              (("1"
                                                                                                                                (assert)
                                                                                                                                (("1"
                                                                                                                                  (case
                                                                                                                                   "p(1)(n(1))=0")
                                                                                                                                  (("1"
                                                                                                                                    (expand
                                                                                                                                     "constructed_sturm_sequence?")
                                                                                                                                    (("1"
                                                                                                                                      (flatten)
                                                                                                                                      (("1"
                                                                                                                                        (inst
                                                                                                                                         -
                                                                                                                                         "1")
                                                                                                                                        (("1"
                                                                                                                                          (assert)
                                                                                                                                          nil
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil)
                                                                                                                                   ("2"
                                                                                                                                    (assert)
                                                                                                                                    (("2"
                                                                                                                                      (ground)
                                                                                                                                      (("1"
                                                                                                                                        (expand
                                                                                                                                         "sign_ext")
                                                                                                                                        (("1"
                                                                                                                                          (lift-if)
                                                                                                                                          (("1"
                                                                                                                                            (assert)
                                                                                                                                            (("1"
                                                                                                                                              (lift-if)
                                                                                                                                              (("1"
                                                                                                                                                (assert)
                                                                                                                                                (("1"
                                                                                                                                                  (lift-if)
                                                                                                                                                  (("1"
                                                                                                                                                    (assert)
                                                                                                                                                    (("1"
                                                                                                                                                      (ground)
                                                                                                                                                      nil
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil)
                                                                                                                                       ("2"
                                                                                                                                        (expand
                                                                                                                                         "sign_ext")
                                                                                                                                        (("2"
                                                                                                                                          (lift-if)
                                                                                                                                          (("2"
                                                                                                                                            (assert)
                                                                                                                                            (("2"
                                                                                                                                              (lift-if)
                                                                                                                                              (("2"
                                                                                                                                                (assert)
                                                                                                                                                (("2"
                                                                                                                                                  (lift-if)
                                                                                                                                                  (("2"
                                                                                                                                                    (assert)
                                                                                                                                                    (("2"
                                                                                                                                                      (ground)
                                                                                                                                                      nil
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil)
                                                                                                                                       ("3"
                                                                                                                                        (expand
                                                                                                                                         "sign_ext")
                                                                                                                                        (("3"
                                                                                                                                          (lift-if)
                                                                                                                                          (("3"
                                                                                                                                            (assert)
                                                                                                                                            (("3"
                                                                                                                                              (lift-if)
                                                                                                                                              (("3"
                                                                                                                                                (assert)
                                                                                                                                                (("3"
                                                                                                                                                  (lift-if)
                                                                                                                                                  (("3"
                                                                                                                                                    (assert)
                                                                                                                                                    (("3"
                                                                                                                                                      (ground)
                                                                                                                                                      nil
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil)
                                                                                                                                       ("4"
                                                                                                                                        (expand
                                                                                                                                         "sign_ext")
                                                                                                                                        (("4"
                                                                                                                                          (lift-if)
                                                                                                                                          (("4"
                                                                                                                                            (assert)
                                                                                                                                            (("4"
                                                                                                                                              (lift-if)
                                                                                                                                              (("4"
                                                                                                                                                (assert)
                                                                                                                                                (("4"
                                                                                                                                                  (lift-if)
                                                                                                                                                  (("4"
                                                                                                                                                    (assert)
                                                                                                                                                    (("4"
                                                                                                                                                      (ground)
                                                                                                                                                      nil
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil)
                                                                                                                                       ("5"
                                                                                                                                        (expand
                                                                                                                                         "sign_ext")
                                                                                                                                        (("5"
                                                                                                                                          (lift-if)
                                                                                                                                          (("5"
                                                                                                                                            (assert)
                                                                                                                                            (("5"
                                                                                                                                              (lift-if)
                                                                                                                                              (("5"
                                                                                                                                                (assert)
                                                                                                                                                (("5"
                                                                                                                                                  (lift-if)
                                                                                                                                                  (("5"
                                                                                                                                                    (assert)
                                                                                                                                                    (("5"
                                                                                                                                                      (ground)
                                                                                                                                                      nil
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil)
                                                                                                                                       ("6"
                                                                                                                                        (expand
                                                                                                                                         "sign_ext")
                                                                                                                                        (("6"
                                                                                                                                          (lift-if)
                                                                                                                                          (("6"
                                                                                                                                            (assert)
                                                                                                                                            (("6"
                                                                                                                                              (lift-if)
                                                                                                                                              (("6"
                                                                                                                                                (assert)
                                                                                                                                                (("6"
                                                                                                                                                  (lift-if)
                                                                                                                                                  (("6"
                                                                                                                                                    (assert)
                                                                                                                                                    (("6"
                                                                                                                                                      (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)
                                                                                                         ("2"
                                                                                                          (copy
                                                                                                           -8)
                                                                                                          (("2"
                                                                                                            (expand
                                                                                                             "constructed_sturm_sequence?"
                                                                                                             -1)
                                                                                                            (("2"
                                                                                                              (flatten)
                                                                                                              (("2"
                                                                                                                (replace
                                                                                                                 -4
                                                                                                                 1)
                                                                                                                (("2"
                                                                                                                  (replace
                                                                                                                   -5
                                                                                                                   1)
                                                                                                                  (("2"
                                                                                                                    (assert)
                                                                                                                    (("2"
                                                                                                                      (rewrite
                                                                                                                       "root_degree_mult")
                                                                                                                      (("1"
                                                                                                                        (rewrite
                                                                                                                         "root_degree_deriv")
                                                                                                                        (("1"
                                                                                                                          (assert)
                                                                                                                          nil
                                                                                                                          nil))
                                                                                                                        nil)
                                                                                                                       ("2"
                                                                                                                        (expand
                                                                                                                         "poly_deriv"
                                                                                                                         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)
                                                                             ("2"
                                                                              (hide
                                                                               7)
                                                                              (("2"
                                                                                (copy
                                                                                 -5)
                                                                                (("2"
                                                                                  (expand
                                                                                   "constructed_sturm_sequence?"
                                                                                   -1)
                                                                                  (("2"
                                                                                    (flatten)
                                                                                    (("2"
                                                                                      (replace
                                                                                       -4
                                                                                       2)
                                                                                      (("2"
                                                                                        (replace
                                                                                         -5
                                                                                         2)
                                                                                        (("2"
                                                                                          (assert)
                                                                                          (("2"
                                                                                            (rewrite
                                                                                             "polynomial_prod_def"
                                                                                             :dir
                                                                                             rl)
                                                                                            (("2"
                                                                                              (rewrite
                                                                                               "sign_ext_mult")
                                                                                              (("2"
                                                                                                (expand
                                                                                                 "sign_ext"
                                                                                                 +
                                                                                                 2)
                                                                                                (("2"
                                                                                                  (expand
                                                                                                   "sign_ext"
                                                                                                   +
                                                                                                   2)
                                                                                                  (("2"
                                                                                                    (lift-if)
                                                                                                    (("2"
                                                                                                      (assert)
                                                                                                      (("2"
                                                                                                        (ground)
                                                                                                        (("2"
                                                                                                          (replace
                                                                                                           -4
                                                                                                           6)
                                                                                                          (("2"
                                                                                                            (replace
                                                                                                             -5)
                                                                                                            (("2"
                                                                                                              (rewrite
                                                                                                               "polynomial_prod_def"
                                                                                                               :dir
                                                                                                               rl)
                                                                                                              (("2"
                                                                                                                (assert)
                                                                                                                nil
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (assert)
                                                                            (("2"
                                                                              (hide
                                                                               7)
                                                                              (("2"
                                                                                (case
                                                                                 "polynomial(poly_deriv(p(0)), n(0) - 1)(x)=0")
                                                                                (("1"
                                                                                  (copy
                                                                                   -5)
                                                                                  (("1"
                                                                                    (expand
                                                                                     "constructed_sturm_sequence?"
                                                                                     -1)
                                                                                    (("1"
                                                                                      (flatten)
                                                                                      (("1"
                                                                                        (assert)
                                                                                        (("1"
                                                                                          (replace
                                                                                           -4)
                                                                                          (("1"
                                                                                            (replace
                                                                                             -5)
                                                                                            (("1"
                                                                                              (rewrite
                                                                                               "polynomial_prod_def"
                                                                                               :dir
                                                                                               rl)
                                                                                              (("1"
                                                                                                (rewrite
                                                                                                 "polynomial_prod_def"
                                                                                                 :dir
                                                                                                 rl)
                                                                                                (("1"
                                                                                                  (assert)
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (expand
                                                                                   "sign_ext"
                                                                                   +)
                                                                                  (("2"
                                                                                    (lift-if)
                                                                                    (("2"
                                                                                      (assert)
                                                                                      (("2"
                                                                                        (lift-if)
                                                                                        (("2"
                                                                                          (assert)
                                                                                          (("2"
                                                                                            (lift-if)
                                                                                            (("2"
                                                                                              (assert)
                                                                                              (("2"
                                                                                                (ground)
                                                                                                (("1"
                                                                                                  (lemma
                                                                                                   "poly_decreasing")
                                                                                                  (("1"
                                                                                                    (inst
                                                                                                     -
                                                                                                     "p(0)"
                                                                                                     "n(0)"
                                                                                                     "x"
                                                                                                     "z")
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      (("1"
                                                                                                        (case
                                                                                                         "n(0)>0")
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          (("1"
                                                                                                            (skosimp*)
                                                                                                            (("1"
                                                                                                              (lemma
                                                                                                               "poly_intermediate_value_inc")
                                                                                                              (("1"
                                                                                                                (inst
                                                                                                                 -
                                                                                                                 "poly_deriv(p(0))"
                                                                                                                 "0"
                                                                                                                 "n(0)-1"
                                                                                                                 "x"
                                                                                                                 "c!1")
                                                                                                                (("1"
                                                                                                                  (assert)
                                                                                                                  (("1"
                                                                                                                    (skosimp*)
                                                                                                                    (("1"
                                                                                                                      (reveal
                                                                                                                       "igz")
                                                                                                                      (("1"
                                                                                                                        (copy
                                                                                                                         -2)
                                                                                                                        (("1"
                                                                                                                          (hide
                                                                                                                           "igz")
                                                                                                                          (("1"
                                                                                                                            (inst
                                                                                                                             -
                                                                                                                             "cc!1")
                                                                                                                            (("1"
                                                                                                                              (assert)
                                                                                                                              (("1"
                                                                                                                                (flatten)
                                                                                                                                (("1"
                                                                                                                                  (copy
                                                                                                                                   "css")
                                                                                                                                  (("1"
                                                                                                                                    (expand
                                                                                                                                     "constructed_sturm_sequence?"
                                                                                                                                     -1)
                                                                                                                                    (("1"
                                                                                                                                      (flatten)
                                                                                                                                      (("1"
                                                                                                                                        (replace
                                                                                                                                         -3
                                                                                                                                         2)
                                                                                                                                        (("1"
                                                                                                                                          (replace
                                                                                                                                           -4
                                                                                                                                           2)
                                                                                                                                          (("1"
                                                                                                                                            (rewrite
                                                                                                                                             "polynomial_prod_def"
                                                                                                                                             :dir
                                                                                                                                             rl)
                                                                                                                                            (("1"
                                                                                                                                              (assert)
                                                                                                                                              nil
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (assert)
                                                                                                          (("2"
                                                                                                            (copy
                                                                                                             "css")
                                                                                                            (("2"
                                                                                                              (expand
                                                                                                               "constructed_sturm_sequence?"
                                                                                                               -1)
                                                                                                              (("2"
                                                                                                                (propax)
                                                                                                                nil
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil)
                                                                                                 ("2"
                                                                                                  (lemma
                                                                                                   "poly_increasing")
                                                                                                  (("2"
                                                                                                    (inst
                                                                                                     -
                                                                                                     "p(0)"
                                                                                                     "n(0)"
                                                                                                     "x"
                                                                                                     "z")
                                                                                                    (("2"
                                                                                                      (assert)
                                                                                                      (("2"
                                                                                                        (case
                                                                                                         "n(0)>0")
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          (("1"
                                                                                                            (skeep)
                                                                                                            (("1"
                                                                                                              (lemma
                                                                                                               "poly_intermediate_value_dec")
                                                                                                              (("1"
                                                                                                                (inst
                                                                                                                 -
                                                                                                                 "poly_deriv(p(0))"
                                                                                                                 "0"
                                                                                                                 "n(0)-1"
                                                                                                                 "x"
                                                                                                                 "c")
                                                                                                                (("1"
                                                                                                                  (assert)
                                                                                                                  (("1"
                                                                                                                    (skeep
                                                                                                                     -1)
                                                                                                                    (("1"
                                                                                                                      (reveal
                                                                                                                       "igz")
                                                                                                                      (("1"
                                                                                                                        (copy
                                                                                                                         -2)
                                                                                                                        (("1"
                                                                                                                          (hide
                                                                                                                           "igz")
                                                                                                                          (("1"
                                                                                                                            (inst
                                                                                                                             -
                                                                                                                             "cc")
                                                                                                                            (("1"
                                                                                                                              (assert)
                                                                                                                              (("1"
                                                                                                                                (flatten)
                                                                                                                                (("1"
                                                                                                                                  (copy
                                                                                                                                   "css")
                                                                                                                                  (("1"
                                                                                                                                    (expand
                                                                                                                                     "constructed_sturm_sequence?"
                                                                                                                                     -1)
                                                                                                                                    (("1"
                                                                                                                                      (flatten)
                                                                                                                                      (("1"
                                                                                                                                        (replace
                                                                                                                                         -3
                                                                                                                                         2)
                                                                                                                                        (("1"
                                                                                                                                          (replace
                                                                                                                                           -4
                                                                                                                                           2)
                                                                                                                                          (("1"
                                                                                                                                            (rewrite
                                                                                                                                             "polynomial_prod_def"
                                                                                                                                             :dir
                                                                                                                                             rl)
                                                                                                                                            (("1"
                                                                                                                                              (assert)
                                                                                                                                              nil
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (expand
                                                                                                           "constructed_sturm_sequence?")
                                                                                                          (("2"
                                                                                                            (flatten)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("3"
                                                                            (expand
                                                                             "constructed_sturm_sequence?")
                                                                            (("3"
                                                                              (flatten)
                                                                              (("3"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2" (assertnil nil))
                              nil))
                            nil)
                           ("2" (expand "constructed_sturm_sequence?")
                            (("2" (assertnil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (inst - "0")
                    (("2" (expand "only_root_between?")
                      (("2" (ground) nil nil)) nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (skeep)
            (("2"
              (case "FORALL (rr:real): x<=rr AND rr<=y IMPLIES polynomial(g,k)(rr)/=0")
              (("1" (inst-cp - "xy")
                (("1" (inst-cp - "xr")
                  (("1" (assert)
                    (("1" (flatten)
                      (("1" (expand "sign_ext" 3)
                        (("1" (lift-if)
                          (("1" (assert)
                            (("1" (lift-if)
                              (("1"
                                (assert)
                                (("1"
                                  (lift-if)
                                  (("1"
                                    (assert)
                                    (("1"
                                      (ground)
                                      (("1"
                                        (lemma
                                         "poly_intermediate_value_inc")
                                        (("1"
                                          (inst
                                           -
                                           "g"
                                           "0"
                                           "k"
                                           "xy"
                                           "xr")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (skosimp*)
                                              (("1"
                                                (inst - "cc!1")
                                                (("1"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (lemma
                                         "poly_intermediate_value_dec")
                                        (("2"
                                          (inst
                                           -
                                           "g"
                                           "0"
                                           "k"
                                           "xy"
                                           "xr")
                                          (("2"
                                            (assert)
                                            (("2"
                                              (skeep -)
                                              (("2"
                                                (inst - "cc")
                                                (("2"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (skeep)
                (("2" (inst - "1")
                  (("1" (expand "only_root_between?")
                    (("1" (flatten)
                      (("1" (assert)
                        (("1" (inst - "rr")
                          (("1" (assert)
                            (("1" (flatten)
                              (("1"
                                (copy "css")
                                (("1"
                                  (expand
                                   "constructed_sturm_sequence?"
                                   -1)
                                  (("1"
                                    (flatten)
                                    (("1"
                                      (replace -4 3)
                                      (("1"
                                        (replace -5 3)
                                        (("1"
                                          (rewrite
                                           "polynomial_prod_def"
                                           :dir
                                           rl)
                                          (("1" (assertnil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (expand "constructed_sturm_sequence?")
                    (("2" (assertnil 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)
    (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)
    (sign_ext const-decl
     "{sig: real | (sig = -1 OR sig = 1 OR sig = 0) AND sig * x = abs(x)}"
     sign "reals/")
    (abs const-decl "{n: nonneg_real | n >= m AND n >= -m}" real_defs
         nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (>= const-decl "bool" reals nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans 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)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (m skolem-const-decl "posnat" sturmtarski nil)
    (only_root_between? const-decl "bool" more_polynomial_props
     "reals/")
    (minus_real_is_real application-judgement "real" reals nil)
    (poly_deriv const-decl "real" polynomials "reals/")
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (sign_ext_mult formula-decl nil sign "reals/")
    (polynomial_prod_def formula-decl nil polynomials "reals/")
    (root_degree_pos formula-decl nil more_polynomial_props "reals/")
    (NOT const-decl "[bool -> bool]" booleans nil)
    (/= const-decl "boolean" notequal nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (constructed_sturm_sequence? const-decl "bool" sturmtarski nil)
    (root_degree_mult formula-decl nil more_polynomial_props "reals/")
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (root_degree_deriv formula-decl nil more_polynomial_props "reals/")
    (odd_iff_even_succ formula-decl nil naturalnumbers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (nzint_times_nzint_is_nzint application-judgement "nzint" integers
     nil)
    (root_degree_even formula-decl nil more_polynomial_props "reals/")
    (even_or_odd formula-decl nil naturalnumbers nil)
    (root_degree def-decl "{m |
         m <= n AND
          (a(n) /= 0 IMPLIES
            ((EXISTS (b: [nat -> real]):
                (FORALL (x):
                   polynomial(a, n)(x) =
                    (x - y) ^ m * polynomial(b, n - m)(x))
                 AND polynomial(b, n - m)(y) /= 0 AND b(n - m) /= 0)
              AND
              (polynomial(a, n)(y) = 0 IMPLIES m > 0) AND
               ((n > 0 AND m > 0) IMPLIES
                 (EXISTS (q: [nat -> real]):
                    (FORALL (x):
                       polynomial(poly_deriv(a), n - 1)(x) =
                        (x - y) ^ (m - 1) * polynomial(q, n - m)(x))
                     AND polynomial(q, n - m)(y) /= 0))))}"
     more_polynomial_props "reals/")
    (^ const-decl "real" exponentiation nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (poly_increasing formula-decl nil polynomials "reals/")
    (poly_intermediate_value_dec formula-decl nil polynomials "reals/")
    (poly_decreasing formula-decl nil polynomials "reals/")
    (poly_intermediate_value_inc formula-decl nil polynomials "reals/")
    (number_sign_changes def-decl "NSC" number_sign_changes "Sturm/")
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props 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)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil)
  (sturm_tarski_basic_1-4 nil 3617696022
   ("" (skeep)
    (("" (label "igz" -2)
      ((""
        (case "FORALL (xy,xr:real): x<=xy AND xy<=xr AND xr<=y IMPLIES sign_ext(polynomial(g,k)(xy)) = sign_ext(polynomial(g,k)(xr))")
        (("1" (inst-cp - "x" "z")
          (("1" (inst - "z" "y")
            (("1" (assert)
              (("1" (case "x<=z AND z<=y")
                (("1" (flatten)
                  (("1" (assert)
                    (("1" (hide (-1 -2))
                      (("1" (case "m>=2")
                        (("1" (inst-cp - "0")
                          (("1" (inst - "1")
                            (("1" (assert)
                              (("1"
                                (expand "only_root_between?")
                                (("1"
                                  (flatten)
                                  (("1"
                                    (hide (-5 -6))
                                    (("1"
                                      (assert)
                                      (("1"
                                        (inst-cp - "x")
                                        (("1"
                                          (inst - "y")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (inst-cp - "x")
                                              (("1"
                                                (inst - "y")
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (flatten)
                                                    (("1"
                                                      (expand
                                                       "number_sign_changes")
                                                      (("1"
                                                        (expand
                                                         "number_sign_changes")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (lift-if)
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (lift-if)
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (lift-if)
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (case
                                                                         "sign_ext(polynomial(poly_deriv(p(0)), n(0)-1)(x)) =
                                                                                        -sign_ext(polynomial(p(0), n(0))(x))")
                                                                        (("1"
                                                                          (case
                                                                           "sign_ext(polynomial(p(0),n(0))(x)) = -sign_ext(polynomial(g,k)(x))*sign_ext(polynomial(p(1),n(1))(x))")
                                                                          (("1"
                                                                            (hide
                                                                             -2)
                                                                            (("1"
                                                                              (assert)
                                                                              (("1"
                                                                                (lemma
                                                                                 "root_degree_pos")
                                                                                (("1"
                                                                                  (lemma
                                                                                   "root_degree_pos")
                                                                                  (("1"
                                                                                    (inst-cp
                                                                                     -
                                                                                     "p(0)"
                                                                                     "n(0)"
                                                                                     "z")
                                                                                    (("1"
                                                                                      (assert)
                                                                                      (("1"
                                                                                        (inst
                                                                                         -
                                                                                         "g"
                                                                                         "k"
                                                                                         "z")
                                                                                        (("1"
                                                                                          (assert)
                                                                                          (("1"
                                                                                            (case
                                                                                             "NOT (p(0)(n(0))/=0 AND g(k)/=0)")
                                                                                            (("1"
                                                                                              (expand
                                                                                               "constructed_sturm_sequence?")
                                                                                              (("1"
                                                                                                (flatten)
                                                                                                (("1"
                                                                                                  (inst
                                                                                                   -
                                                                                                   "0")
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    nil
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil)
                                                                                             ("2"
                                                                                              (flatten)
                                                                                              (("2"
                                                                                                (assert)
                                                                                                (("2"
                                                                                                  (name
                                                                                                   "dd"
                                                                                                   "root_degree(p(0),n(0))(z)")
                                                                                                  (("2"
                                                                                                    (replace
                                                                                                     -1)
                                                                                                    (("2"
                                                                                                      (case
                                                                                                       "root_degree(p(1),n(1))(z) = dd-1")
                                                                                                      (("1"
                                                                                                        (assert)
                                                                                                        (("1"
                                                                                                          (lemma
                                                                                                           "even_or_odd")
                                                                                                          (("1"
                                                                                                            (inst-cp
                                                                                                             -
                                                                                                             "dd")
                                                                                                            (("1"
                                                                                                              (inst
                                                                                                               -
                                                                                                               "dd-1")
                                                                                                              (("1"
                                                                                                                (lemma
                                                                                                                 "odd_iff_even_succ")
                                                                                                                (("1"
                                                                                                                  (inst
                                                                                                                   -
                                                                                                                   "dd-1")
                                                                                                                  (("1"
                                                                                                                    (assert)
                                                                                                                    (("1"
                                                                                                                      (lemma
                                                                                                                       "root_degree_even")
                                                                                                                      (("1"
                                                                                                                        (inst-cp
                                                                                                                         -
                                                                                                                         "p(0)"
                                                                                                                         "n(0)"
                                                                                                                         "x"
                                                                                                                         "y"
                                                                                                                         "z")
                                                                                                                        (("1"
                                                                                                                          (assert)
                                                                                                                          (("1"
                                                                                                                            (inst
                                                                                                                             -
                                                                                                                             "p(1)"
                                                                                                                             "n(1)"
                                                                                                                             "x"
                                                                                                                             "y"
                                                                                                                             "z")
                                                                                                                            (("1"
                                                                                                                              (assert)
                                                                                                                              (("1"
                                                                                                                                (case
                                                                                                                                 "p(1)(n(1))=0")
                                                                                                                                (("1"
                                                                                                                                  (expand
                                                                                                                                   "constructed_sturm_sequence?")
                                                                                                                                  (("1"
                                                                                                                                    (flatten)
                                                                                                                                    (("1"
                                                                                                                                      (inst
                                                                                                                                       -
                                                                                                                                       "1")
                                                                                                                                      (("1"
                                                                                                                                        (assert)
                                                                                                                                        nil
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil)
                                                                                                                                 ("2"
                                                                                                                                  (assert)
                                                                                                                                  (("2"
                                                                                                                                    (ground)
                                                                                                                                    (("1"
                                                                                                                                      (expand
                                                                                                                                       "sign_ext")
                                                                                                                                      (("1"
                                                                                                                                        (lift-if)
                                                                                                                                        (("1"
                                                                                                                                          (assert)
                                                                                                                                          (("1"
                                                                                                                                            (lift-if)
                                                                                                                                            (("1"
                                                                                                                                              (assert)
                                                                                                                                              (("1"
                                                                                                                                                (lift-if)
                                                                                                                                                (("1"
                                                                                                                                                  (assert)
                                                                                                                                                  (("1"
                                                                                                                                                    (ground)
                                                                                                                                                    nil
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil)
                                                                                                                                     ("2"
                                                                                                                                      (expand
                                                                                                                                       "sign_ext")
                                                                                                                                      (("2"
                                                                                                                                        (lift-if)
                                                                                                                                        (("2"
                                                                                                                                          (assert)
                                                                                                                                          (("2"
                                                                                                                                            (lift-if)
                                                                                                                                            (("2"
                                                                                                                                              (assert)
                                                                                                                                              (("2"
                                                                                                                                                (lift-if)
                                                                                                                                                (("2"
                                                                                                                                                  (assert)
                                                                                                                                                  (("2"
                                                                                                                                                    (ground)
                                                                                                                                                    nil
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil)
                                                                                                                                     ("3"
                                                                                                                                      (expand
                                                                                                                                       "sign_ext")
                                                                                                                                      (("3"
                                                                                                                                        (lift-if)
                                                                                                                                        (("3"
                                                                                                                                          (assert)
                                                                                                                                          (("3"
                                                                                                                                            (lift-if)
                                                                                                                                            (("3"
                                                                                                                                              (assert)
                                                                                                                                              (("3"
                                                                                                                                                (lift-if)
                                                                                                                                                (("3"
                                                                                                                                                  (assert)
                                                                                                                                                  (("3"
                                                                                                                                                    (ground)
                                                                                                                                                    nil
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil)
                                                                                                                                     ("4"
                                                                                                                                      (expand
                                                                                                                                       "sign_ext")
                                                                                                                                      (("4"
                                                                                                                                        (lift-if)
                                                                                                                                        (("4"
                                                                                                                                          (assert)
                                                                                                                                          (("4"
                                                                                                                                            (lift-if)
                                                                                                                                            (("4"
                                                                                                                                              (assert)
                                                                                                                                              (("4"
                                                                                                                                                (lift-if)
                                                                                                                                                (("4"
                                                                                                                                                  (assert)
                                                                                                                                                  (("4"
                                                                                                                                                    (ground)
                                                                                                                                                    nil
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil)
                                                                                                                                     ("5"
                                                                                                                                      (expand
                                                                                                                                       "sign_ext")
                                                                                                                                      (("5"
                                                                                                                                        (lift-if)
                                                                                                                                        (("5"
                                                                                                                                          (assert)
                                                                                                                                          (("5"
                                                                                                                                            (lift-if)
                                                                                                                                            (("5"
                                                                                                                                              (assert)
                                                                                                                                              (("5"
                                                                                                                                                (lift-if)
                                                                                                                                                (("5"
                                                                                                                                                  (assert)
                                                                                                                                                  (("5"
                                                                                                                                                    (ground)
                                                                                                                                                    nil
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil)
                                                                                                                                     ("6"
                                                                                                                                      (expand
                                                                                                                                       "sign_ext")
                                                                                                                                      (("6"
                                                                                                                                        (lift-if)
                                                                                                                                        (("6"
                                                                                                                                          (assert)
                                                                                                                                          (("6"
                                                                                                                                            (lift-if)
                                                                                                                                            (("6"
                                                                                                                                              (assert)
                                                                                                                                              (("6"
                                                                                                                                                (lift-if)
                                                                                                                                                (("6"
                                                                                                                                                  (assert)
                                                                                                                                                  (("6"
                                                                                                                                                    (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)
                                                                                                       ("2"
                                                                                                        (copy
                                                                                                         -8)
                                                                                                        (("2"
                                                                                                          (expand
                                                                                                           "constructed_sturm_sequence?"
                                                                                                           -1)
                                                                                                          (("2"
                                                                                                            (flatten)
                                                                                                            (("2"
                                                                                                              (replace
                                                                                                               -4
                                                                                                               1)
                                                                                                              (("2"
                                                                                                                (replace
                                                                                                                 -5
                                                                                                                 1)
                                                                                                                (("2"
                                                                                                                  (assert)
                                                                                                                  (("2"
                                                                                                                    (rewrite
                                                                                                                     "root_degree_mult")
                                                                                                                    (("1"
                                                                                                                      (rewrite
                                                                                                                       "root_degree_deriv")
                                                                                                                      (("1"
                                                                                                                        (assert)
                                                                                                                        nil
                                                                                                                        nil))
                                                                                                                      nil)
                                                                                                                     ("2"
                                                                                                                      (expand
                                                                                                                       "poly_deriv"
                                                                                                                       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)
                                                                           ("2"
                                                                            (hide
                                                                             7)
                                                                            (("2"
                                                                              (copy
                                                                               -5)
                                                                              (("2"
                                                                                (expand
                                                                                 "constructed_sturm_sequence?"
                                                                                 -1)
                                                                                (("2"
                                                                                  (flatten)
                                                                                  (("2"
                                                                                    (replace
                                                                                     -4
                                                                                     2)
                                                                                    (("2"
                                                                                      (replace
                                                                                       -5
                                                                                       2)
                                                                                      (("2"
                                                                                        (assert)
                                                                                        (("2"
                                                                                          (rewrite
                                                                                           "polynomial_prod_def"
                                                                                           :dir
                                                                                           rl)
                                                                                          (("2"
                                                                                            (rewrite
                                                                                             "sign_ext_mult")
                                                                                            (("2"
                                                                                              (expand
                                                                                               "sign_ext"
                                                                                               +
                                                                                               2)
                                                                                              (("2"
                                                                                                (expand
                                                                                                 "sign_ext"
                                                                                                 +
                                                                                                 2)
                                                                                                (("2"
                                                                                                  (lift-if)
                                                                                                  (("2"
                                                                                                    (assert)
                                                                                                    (("2"
                                                                                                      (ground)
                                                                                                      (("2"
                                                                                                        (replace
                                                                                                         -4
                                                                                                         6)
                                                                                                        (("2"
                                                                                                          (replace
                                                                                                           -5)
                                                                                                          (("2"
                                                                                                            (rewrite
                                                                                                             "polynomial_prod_def"
                                                                                                             :dir
                                                                                                             rl)
                                                                                                            (("2"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (assert)
                                                                          (("2"
                                                                            (hide
                                                                             7)
                                                                            (("2"
                                                                              (case
                                                                               "polynomial(poly_deriv(p(0)), n(0) - 1)(x)=0")
                                                                              (("1"
                                                                                (copy
                                                                                 -5)
                                                                                (("1"
                                                                                  (expand
                                                                                   "constructed_sturm_sequence?"
                                                                                   -1)
                                                                                  (("1"
                                                                                    (flatten)
                                                                                    (("1"
                                                                                      (assert)
                                                                                      (("1"
                                                                                        (replace
                                                                                         -4)
                                                                                        (("1"
                                                                                          (replace
                                                                                           -5)
                                                                                          (("1"
                                                                                            (rewrite
                                                                                             "polynomial_prod_def"
                                                                                             :dir
                                                                                             rl)
                                                                                            (("1"
                                                                                              (rewrite
                                                                                               "polynomial_prod_def"
                                                                                               :dir
                                                                                               rl)
                                                                                              (("1"
                                                                                                (assert)
                                                                                                nil
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (expand
                                                                                 "sign_ext"
                                                                                 +)
                                                                                (("2"
                                                                                  (lift-if)
                                                                                  (("2"
                                                                                    (assert)
                                                                                    (("2"
                                                                                      (lift-if)
                                                                                      (("2"
                                                                                        (assert)
                                                                                        (("2"
                                                                                          (lift-if)
                                                                                          (("2"
                                                                                            (assert)
                                                                                            (("2"
                                                                                              (ground)
                                                                                              (("1"
                                                                                                (lemma
                                                                                                 "poly_decreasing")
                                                                                                (("1"
                                                                                                  (inst
                                                                                                   -
                                                                                                   "p(0)"
                                                                                                   "n(0)"
                                                                                                   "x"
                                                                                                   "z")
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    (("1"
                                                                                                      (case
                                                                                                       "n(0)>0")
                                                                                                      (("1"
                                                                                                        (assert)
                                                                                                        (("1"
                                                                                                          (skosimp*)
                                                                                                          (("1"
                                                                                                            (lemma
                                                                                                             "poly_intermediate_value_inc")
                                                                                                            (("1"
                                                                                                              (inst
                                                                                                               -
                                                                                                               "poly_deriv(p(0))"
                                                                                                               "0"
                                                                                                               "n(0)-1"
                                                                                                               "x"
                                                                                                               "c!1")
                                                                                                              (("1"
                                                                                                                (assert)
                                                                                                                (("1"
                                                                                                                  (skosimp*)
                                                                                                                  (("1"
                                                                                                                    (reveal
                                                                                                                     "igz")
                                                                                                                    (("1"
                                                                                                                      (copy
                                                                                                                       -2)
                                                                                                                      (("1"
                                                                                                                        (hide
                                                                                                                         "igz")
                                                                                                                        (("1"
                                                                                                                          (inst
                                                                                                                           -
                                                                                                                           "cc!1")
                                                                                                                          (("1"
                                                                                                                            (assert)
                                                                                                                            (("1"
                                                                                                                              (flatten)
                                                                                                                              (("1"
                                                                                                                                (copy
                                                                                                                                 -12)
                                                                                                                                (("1"
                                                                                                                                  (postpone)
                                                                                                                                  nil
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil)
                                                                                                       ("2"
                                                                                                        (postpone)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil)
                                                                                               ("2"
                                                                                                (postpone)
                                                                                                nil
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("3"
                                                                          (postpone)
                                                                          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" (postpone) nil nil))
                            nil))
                          nil)
                         ("2" (postpone) nil nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (postpone) nil nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (postpone) nil nil))
        nil))
      nil))
    nil)
   nil nil)
  (sturm_tarski_basic_1-3 nil 3617644038
   ("" (skeep)
    ((""
      (case "FORALL (xy,xr:real): x<=xy AND xy<=xr AND xr<=y IMPLIES sign_ext(polynomial(g,k)(xy)) = sign_ext(polynomial(g,k)(xr))")
      (("1" (inst-cp - "x" "z")
        (("1" (inst - "z" "y")
          (("1" (assert)
            (("1" (case "x<=z AND z<=y")
              (("1" (flatten)
                (("1" (assert)
                  (("1" (hide (-1 -2))
                    (("1" (case "m>=2")
                      (("1" (inst-cp - "0")
                        (("1" (inst - "1")
                          (("1" (assert)
                            (("1" (expand "only_root_between?")
                              (("1"
                                (flatten)
                                (("1"
                                  (hide (-5 -6))
                                  (("1"
                                    (assert)
                                    (("1"
                                      (inst-cp - "x")
                                      (("1"
                                        (inst - "y")
                                        (("1"
                                          (assert)
                                          (("1"
                                            (inst-cp - "x")
                                            (("1"
                                              (inst - "y")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (flatten)
                                                  (("1"
                                                    (expand
                                                     "number_sign_changes")
                                                    (("1"
                                                      (expand
                                                       "number_sign_changes")
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (lift-if)
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (lift-if)
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (lift-if)
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (case
                                                                       "sign_ext(polynomial(poly_deriv(p(0)), n(0)-1)(x)) =
                                                                         -sign_ext(polynomial(p(0), n(0))(x))")
                                                                      (("1"
                                                                        (case
                                                                         "sign_ext(polynomial(p(0),n(0))(x)) = -sign_ext(polynomial(g,k)(x))*sign_ext(polynomial(p(1),n(1))(x))")
                                                                        (("1"
                                                                          (hide
                                                                           -2)
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (lemma
                                                                               "root_degree_pos")
                                                                              (("1"
                                                                                (lemma
                                                                                 "root_degree_pos")
                                                                                (("1"
                                                                                  (inst-cp
                                                                                   -
                                                                                   "p(0)"
                                                                                   "n(0)"
                                                                                   "z")
                                                                                  (("1"
                                                                                    (assert)
                                                                                    (("1"
                                                                                      (inst
                                                                                       -
                                                                                       "g"
                                                                                       "k"
                                                                                       "z")
                                                                                      (("1"
                                                                                        (assert)
                                                                                        (("1"
                                                                                          (case
                                                                                           "NOT (p(0)(n(0))/=0 AND g(k)/=0)")
                                                                                          (("1"
                                                                                            (expand
                                                                                             "constructed_sturm_sequence?")
                                                                                            (("1"
                                                                                              (flatten)
                                                                                              (("1"
                                                                                                (inst
                                                                                                 -
                                                                                                 "0")
                                                                                                (("1"
                                                                                                  (assert)
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (flatten)
                                                                                            (("2"
                                                                                              (assert)
                                                                                              (("2"
                                                                                                (name
                                                                                                 "dd"
                                                                                                 "root_degree(p(0),n(0))(z)")
                                                                                                (("2"
                                                                                                  (replace
                                                                                                   -1)
                                                                                                  (("2"
                                                                                                    (case
                                                                                                     "root_degree(p(1),n(1))(z) = dd-1")
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      (("1"
                                                                                                        (lemma
                                                                                                         "even_or_odd")
                                                                                                        (("1"
                                                                                                          (inst-cp
                                                                                                           -
                                                                                                           "dd")
                                                                                                          (("1"
                                                                                                            (inst
                                                                                                             -
                                                                                                             "dd-1")
                                                                                                            (("1"
                                                                                                              (lemma
                                                                                                               "odd_iff_even_succ")
                                                                                                              (("1"
                                                                                                                (inst
                                                                                                                 -
                                                                                                                 "dd-1")
                                                                                                                (("1"
                                                                                                                  (assert)
                                                                                                                  (("1"
                                                                                                                    (lemma
                                                                                                                     "root_degree_even")
                                                                                                                    (("1"
                                                                                                                      (inst-cp
                                                                                                                       -
                                                                                                                       "p(0)"
                                                                                                                       "n(0)"
                                                                                                                       "x"
                                                                                                                       "y"
                                                                                                                       "z")
                                                                                                                      (("1"
                                                                                                                        (assert)
                                                                                                                        (("1"
                                                                                                                          (inst
                                                                                                                           -
                                                                                                                           "p(1)"
                                                                                                                           "n(1)"
                                                                                                                           "x"
                                                                                                                           "y"
                                                                                                                           "z")
                                                                                                                          (("1"
                                                                                                                            (assert)
                                                                                                                            (("1"
                                                                                                                              (case
                                                                                                                               "p(1)(n(1))=0")
                                                                                                                              (("1"
                                                                                                                                (expand
                                                                                                                                 "constructed_sturm_sequence?")
                                                                                                                                (("1"
                                                                                                                                  (flatten)
                                                                                                                                  (("1"
                                                                                                                                    (inst
                                                                                                                                     -
                                                                                                                                     "1")
                                                                                                                                    (("1"
                                                                                                                                      (assert)
                                                                                                                                      nil
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil)
                                                                                                                               ("2"
                                                                                                                                (assert)
                                                                                                                                (("2"
                                                                                                                                  (ground)
                                                                                                                                  (("1"
                                                                                                                                    (expand
                                                                                                                                     "sign_ext")
                                                                                                                                    (("1"
                                                                                                                                      (lift-if)
                                                                                                                                      (("1"
                                                                                                                                        (assert)
                                                                                                                                        (("1"
                                                                                                                                          (lift-if)
                                                                                                                                          (("1"
                                                                                                                                            (assert)
                                                                                                                                            (("1"
                                                                                                                                              (lift-if)
                                                                                                                                              (("1"
                                                                                                                                                (assert)
                                                                                                                                                (("1"
                                                                                                                                                  (ground)
                                                                                                                                                  nil
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil)
                                                                                                                                   ("2"
                                                                                                                                    (expand
                                                                                                                                     "sign_ext")
                                                                                                                                    (("2"
                                                                                                                                      (lift-if)
                                                                                                                                      (("2"
                                                                                                                                        (assert)
                                                                                                                                        (("2"
                                                                                                                                          (lift-if)
                                                                                                                                          (("2"
                                                                                                                                            (assert)
                                                                                                                                            (("2"
                                                                                                                                              (lift-if)
                                                                                                                                              (("2"
                                                                                                                                                (assert)
                                                                                                                                                (("2"
                                                                                                                                                  (ground)
                                                                                                                                                  nil
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil)
                                                                                                                                   ("3"
                                                                                                                                    (expand
                                                                                                                                     "sign_ext")
                                                                                                                                    (("3"
                                                                                                                                      (lift-if)
                                                                                                                                      (("3"
                                                                                                                                        (assert)
                                                                                                                                        (("3"
                                                                                                                                          (lift-if)
                                                                                                                                          (("3"
                                                                                                                                            (assert)
                                                                                                                                            (("3"
                                                                                                                                              (lift-if)
                                                                                                                                              (("3"
                                                                                                                                                (assert)
                                                                                                                                                (("3"
                                                                                                                                                  (ground)
                                                                                                                                                  nil
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil)
                                                                                                                                   ("4"
                                                                                                                                    (expand
                                                                                                                                     "sign_ext")
                                                                                                                                    (("4"
                                                                                                                                      (lift-if)
                                                                                                                                      (("4"
                                                                                                                                        (assert)
                                                                                                                                        (("4"
                                                                                                                                          (lift-if)
                                                                                                                                          (("4"
                                                                                                                                            (assert)
                                                                                                                                            (("4"
                                                                                                                                              (lift-if)
                                                                                                                                              (("4"
                                                                                                                                                (assert)
                                                                                                                                                (("4"
                                                                                                                                                  (ground)
                                                                                                                                                  nil
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil)
                                                                                                                                   ("5"
                                                                                                                                    (expand
                                                                                                                                     "sign_ext")
                                                                                                                                    (("5"
                                                                                                                                      (lift-if)
                                                                                                                                      (("5"
                                                                                                                                        (assert)
                                                                                                                                        (("5"
                                                                                                                                          (lift-if)
                                                                                                                                          (("5"
                                                                                                                                            (assert)
                                                                                                                                            (("5"
                                                                                                                                              (lift-if)
                                                                                                                                              (("5"
                                                                                                                                                (assert)
                                                                                                                                                (("5"
                                                                                                                                                  (ground)
                                                                                                                                                  nil
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil)
                                                                                                                                   ("6"
                                                                                                                                    (expand
                                                                                                                                     "sign_ext")
                                                                                                                                    (("6"
                                                                                                                                      (lift-if)
                                                                                                                                      (("6"
                                                                                                                                        (assert)
                                                                                                                                        (("6"
                                                                                                                                          (lift-if)
                                                                                                                                          (("6"
                                                                                                                                            (assert)
                                                                                                                                            (("6"
                                                                                                                                              (lift-if)
                                                                                                                                              (("6"
                                                                                                                                                (assert)
                                                                                                                                                (("6"
                                                                                                                                                  (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)
                                                                                                     ("2"
                                                                                                      (copy
                                                                                                       -8)
                                                                                                      (("2"
                                                                                                        (expand
                                                                                                         "constructed_sturm_sequence?"
                                                                                                         -1)
                                                                                                        (("2"
                                                                                                          (flatten)
                                                                                                          (("2"
                                                                                                            (replace
                                                                                                             -4
                                                                                                             1)
                                                                                                            (("2"
                                                                                                              (replace
                                                                                                               -5
                                                                                                               1)
                                                                                                              (("2"
                                                                                                                (assert)
                                                                                                                (("2"
                                                                                                                  (rewrite
                                                                                                                   "root_degree_mult")
                                                                                                                  (("1"
                                                                                                                    (rewrite
                                                                                                                     "root_degree_deriv")
                                                                                                                    (("1"
                                                                                                                      (assert)
                                                                                                                      nil
                                                                                                                      nil))
                                                                                                                    nil)
                                                                                                                   ("2"
                                                                                                                    (expand
                                                                                                                     "poly_deriv"
                                                                                                                     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)
                                                                         ("2"
                                                                          (hide
                                                                           7)
                                                                          (("2"
                                                                            (copy
                                                                             -5)
                                                                            (("2"
                                                                              (expand
                                                                               "constructed_sturm_sequence?"
                                                                               -1)
                                                                              (("2"
                                                                                (flatten)
                                                                                (("2"
                                                                                  (replace
                                                                                   -4
                                                                                   2)
                                                                                  (("2"
                                                                                    (replace
                                                                                     -5
                                                                                     2)
                                                                                    (("2"
                                                                                      (assert)
                                                                                      (("2"
                                                                                        (rewrite
                                                                                         "polynomial_prod_def"
                                                                                         :dir
                                                                                         rl)
                                                                                        (("2"
                                                                                          (rewrite
                                                                                           "sign_ext_mult")
                                                                                          (("2"
                                                                                            (expand
                                                                                             "sign_ext"
                                                                                             +
                                                                                             2)
                                                                                            (("2"
                                                                                              (expand
                                                                                               "sign_ext"
                                                                                               +
                                                                                               2)
                                                                                              (("2"
                                                                                                (lift-if)
                                                                                                (("2"
                                                                                                  (assert)
                                                                                                  (("2"
                                                                                                    (ground)
                                                                                                    (("2"
                                                                                                      (replace
                                                                                                       -4
                                                                                                       6)
                                                                                                      (("2"
                                                                                                        (replace
                                                                                                         -5)
                                                                                                        (("2"
                                                                                                          (rewrite
                                                                                                           "polynomial_prod_def"
                                                                                                           :dir
                                                                                                           rl)
                                                                                                          (("2"
                                                                                                            (assert)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (assert)
                                                                        (("2"
                                                                          (hide
                                                                           7)
                                                                          (("2"
                                                                            (case
                                                                             "polynomial(poly_deriv(p(0)), n(0) - 1)(x)=0")
                                                                            (("1"
                                                                              (copy
                                                                               -5)
                                                                              (("1"
                                                                                (expand
                                                                                 "constructed_sturm_sequence?"
                                                                                 -1)
                                                                                (("1"
                                                                                  (flatten)
                                                                                  (("1"
                                                                                    (assert)
                                                                                    (("1"
                                                                                      (replace
                                                                                       -4)
                                                                                      (("1"
                                                                                        (replace
                                                                                         -5)
                                                                                        (("1"
                                                                                          (rewrite
                                                                                           "polynomial_prod_def"
                                                                                           :dir
                                                                                           rl)
                                                                                          (("1"
                                                                                            (rewrite
                                                                                             "polynomial_prod_def"
                                                                                             :dir
                                                                                             rl)
                                                                                            (("1"
                                                                                              (assert)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (expand
                                                                               "sign_ext"
                                                                               +)
                                                                              (("2"
                                                                                (lift-if)
                                                                                (("2"
                                                                                  (assert)
                                                                                  (("2"
                                                                                    (lift-if)
                                                                                    (("2"
                                                                                      (assert)
                                                                                      (("2"
                                                                                        (lift-if)
                                                                                        (("2"
                                                                                          (assert)
                                                                                          (("2"
                                                                                            (ground)
                                                                                            (("1"
                                                                                              (lemma
                                                                                               "poly_decreasing")
                                                                                              (("1"
                                                                                                (inst
                                                                                                 -
                                                                                                 "p(0)"
                                                                                                 "n(0)"
                                                                                                 "x"
                                                                                                 "z")
                                                                                                (("1"
                                                                                                  (assert)
                                                                                                  (("1"
                                                                                                    (case
                                                                                                     "n(0)>0")
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      (("1"
                                                                                                        (skosimp*)
                                                                                                        (("1"
                                                                                                          (lemma
                                                                                                           "poly_intermediate_value_inc")
                                                                                                          (("1"
                                                                                                            (inst
                                                                                                             -
                                                                                                             "poly_deriv(p(0))"
                                                                                                             "0"
                                                                                                             "n(0)-1"
                                                                                                             "x"
                                                                                                             "c!1")
                                                                                                            (("1"
                                                                                                              (assert)
                                                                                                              (("1"
                                                                                                                (skosimp*)
                                                                                                                (("1"
                                                                                                                  (postpone)
                                                                                                                  nil
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (postpone)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil)
                                                                                             ("2"
                                                                                              (postpone)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("3"
                                                                        (postpone)
                                                                        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" (postpone) nil nil))
                          nil))
                        nil)
                       ("2" (postpone) nil nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (postpone) nil nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (postpone) nil nil))
      nil))
    nil)
   nil nil)
  (sturm_tarski_basic_1-2 nil 3617643010
   ("" (skeep)
    ((""
      (case "FORALL (xy,xr:real): x<=xy AND xy<=xr AND xr<=y IMPLIES sign_ext(polynomial(g,k)(xy)) = sign_ext(polynomial(g,k)(xr))")
      (("1" (inst-cp - "x" "z")
        (("1" (inst - "z" "y")
          (("1" (assert)
            (("1" (case "x<=z AND z<=y")
              (("1" (flatten)
                (("1" (assert)
                  (("1" (hide (-1 -2))
                    (("1" (case "m>=2")
                      (("1" (inst-cp - "0")
                        (("1" (inst - "1")
                          (("1" (assert)
                            (("1" (expand "only_root_between?")
                              (("1"
                                (flatten)
                                (("1"
                                  (hide (-5 -6))
                                  (("1"
                                    (assert)
                                    (("1"
                                      (inst-cp - "x")
                                      (("1"
                                        (inst - "y")
                                        (("1"
                                          (assert)
                                          (("1"
                                            (inst-cp - "x")
                                            (("1"
                                              (inst - "y")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (flatten)
                                                  (("1"
                                                    (expand
                                                     "number_sign_changes")
--> --------------------

--> maximum size reached

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

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

¤ Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.0.705Bemerkung:  (vorverarbeitet am  2026-04-26) ¤

*Bot Zugriff






Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

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

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.






                                                                                                                                                                                                                                                                                                                                                                                                     


Neuigkeiten

     Aktuelles
     Motto des Tages

Software

     Produkte
     Quellcodebibliothek

Aktivitäten

     Artikel über Sicherheit
     Anleitung zur Aktivierung von SSL

Muße

     Gedichte
     Musik
     Bilder

Jenseits des Üblichen ....

Besucherstatistik

Besucherstatistik

Monitoring

Montastic status badge