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


Impressum bernstein_polynomials.prf

  Interaktion und
PortierbarkeitLisp
 

(bernstein_polynomials
 (Bern_TCC1 0
  (Bern_TCC1-1 nil 3479200111 ("" (subtype-tcc) nil nilnil nil))
 (Bern_TCC2 0
  (Bern_TCC2-1 nil 3479200111 ("" (subtype-tcc) nil nilnil nil))
 (Bern_TCC3 0
  (Bern_TCC3-1 nil 3479200111 ("" (subtype-tcc) nil nil)
   ((/= const-decl "boolean" notequal nil)) nil))
 (Bern_TCC4 0
  (Bern_TCC4-1 nil 3479200335 ("" (subtype-tcc) nil nil)
   ((/= const-decl "boolean" notequal nil)) nil))
 (Bern_top_TCC1 0
  (Bern_top_TCC1-1 nil 3479206792 ("" (subtype-tcc) nil nilnil nil))
 (Bern_top 0
  (Bern_top-1 nil 3479206793
   ("" (skeep)
    (("" (expand "Bern")
      (("" (expand "C")
        (("" (expand "^" 1 1)
          (("" (expand "expt") (("" (assertnil nil)) nil)) nil))
        nil))
      nil))
    nil)
   ((Bern const-decl "real" bernstein_polynomials nil)
    (^ const-decl "real" exponentiation nil)
    (factorial_0 formula-decl nil factorial "ints/")
    (posrat_div_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (expt def-decl "real" exponentiation nil)
    (C const-decl "posnat" binomial nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil))
   shostak))
 (Bern_bottom_TCC1 0
  (Bern_bottom_TCC1-1 nil 3479206860 ("" (subtype-tcc) nil nilnil
   nil))
 (Bern_bottom_TCC2 0
  (Bern_bottom_TCC2-1 nil 3479206860 ("" (subtype-tcc) nil nil)
   ((/= const-decl "boolean" notequal nil)) nil))
 (Bern_bottom 0
  (Bern_bottom-1 nil 3479206860
   ("" (skeep)
    (("" (expand "Bern")
      (("" (expand "C")
        (("" (expand "^" 1 2)
          (("" (expand "expt") (("" (assertnil nil)) nil)) nil))
        nil))
      nil))
    nil)
   ((Bern const-decl "real" bernstein_polynomials nil)
    (^ const-decl "real" exponentiation nil)
    (factorial_0 formula-decl nil factorial "ints/")
    (posrat_div_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (expt def-decl "real" exponentiation nil)
    (C const-decl "posnat" binomial nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil))
   shostak))
 (Bern_middle_zero 0
  (Bern_middle_zero-1 nil 3480419658
   ("" (skeep)
    (("" (expand "Bern")
      (("" (case "0^i = 0")
        (("1" (assertnil nil)
         ("2" (expand "^" 1)
          (("2" (expand "expt") (("2" (assertnil nil)) nil)) nil))
        nil))
      nil))
    nil)
   ((Bern const-decl "real" bernstein_polynomials nil)
    (nat_expt application-judgement "nat" exponentiation nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (expt def-decl "real" exponentiation nil)
    (nnrat_exp application-judgement "nnrat" exponentiation nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (nnrat_times_nnrat_is_nnrat application-judgement "nonneg_rat"
     rationals nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nat_exp application-judgement "nat" exponentiation nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (real nonempty-type-from-decl nil reals 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)
    (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)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (/= const-decl "boolean" notequal nil)
    (>= const-decl "bool" reals nil)
    (^ const-decl "real" exponentiation nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil))
   shostak))
 (Bern_middle_one 0
  (Bern_middle_one-1 nil 3480419912
   ("" (skeep)
    (("" (expand "Bern")
      (("" (case "0^(nn-i) = 0")
        (("1" (assertnil nil)
         ("2" (expand "^" 1)
          (("2" (expand "expt" 1) (("2" (assertnil nil)) nil)) nil))
        nil))
      nil))
    nil)
   ((Bern const-decl "real" bernstein_polynomials nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (nat_expt application-judgement "nat" exponentiation nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (expt def-decl "real" exponentiation nil)
    (posint_exp application-judgement "posint" exponentiation nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nat_exp application-judgement "nat" exponentiation nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (real nonempty-type-from-decl nil reals 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)
    (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)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (/= const-decl "boolean" notequal nil)
    (>= const-decl "bool" reals nil)
    (^ const-decl "real" exponentiation nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (> const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (above nonempty-type-eq-decl nil integers nil))
   shostak))
 (Bern_Polynomial_TCC1 0
  (Bern_Polynomial_TCC1-1 nil 3479653703 ("" (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)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (above nonempty-type-eq-decl nil 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)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (Bern_Polynomial_TCC2 0
  (Bern_Polynomial_TCC2-1 nil 3479653703 ("" (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)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (above nonempty-type-eq-decl nil 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)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (Bern_Polynomial 0
  (Bern_Polynomial-1 nil 3479653689
   ("" (skeep)
    (("" (decompose-equality)
      (("1" (expand "Bern")
        (("1" (lemma "neg_power_polynomial")
          (("1"
            (case "FORALL (n: nat):
                          (LAMBDA (x: real): (1 - x) ^ n) = polynomial(neg_power_fs(n), n)")
            (("1" (hide -2)
              (("1" (case "nn>=i")
                (("1" (inst - "nn-i")
                  (("1" (decompose-equality)
                    (("1" (inst - "x!1")
                      (("1" (replace -1)
                        (("1" (hide -1)
                          (("1" (expand "polynomial")
                            (("1" (rewrite "sigma_scal" :dir rl)
                              (("1"
                                (name
                                 "Bfun"
                                 "LAMBDA (i_1: nat):
                                                     neg_power_fs(nn - i)(i_1) * C(nn, i) * x!1 ^ i *
                                                      (IF i_1 = 0 THEN 1 ELSE x!1 ^ i_1 ENDIF)")
                                (("1"
                                  (replace -1)
                                  (("1"
                                    (name
                                     "Afun"
                                     "LAMBDA (i_1: nat):
                                                      IF i_1 < i OR i_1 > nn THEN 0
                                                      ELSE C(i_1, i) * C(nn, i_1) * (-1) ^ (i_1 - i)
                                                      ENDIF
                                                       * (IF i_1 = 0 THEN 1 ELSE x!1 ^ i_1 ENDIF)")
                                    (("1"
                                      (replace -1)
                                      (("1"
                                        (lemma "sigma_shift_T2")
                                        (("1"
                                          (inst
                                           -
                                           "lambda (iz:nat):IF iz < i THEN 0 ELSE Bfun(iz-i) ENDIF"
                                           "nn-i"
                                           "0"
                                           "i")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (case
                                               "(LAMBDA (i_1: nat): Bfun(i_1)) = Bfun")
                                              (("1"
                                                (replace -1)
                                                (("1"
                                                  (hide -1)
                                                  (("1"
                                                    (replace
                                                     -1
                                                     :dir
                                                     rl)
                                                    (("1"
                                                      (hide -1)
                                                      (("1"
                                                        (lemma
                                                         "sigma_split")
                                                        (("1"
                                                          (inst
                                                           -
                                                           "Afun"
                                                           "nn"
                                                           "0"
                                                           "i-1")
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (replace
                                                               -1)
                                                              (("1"
                                                                (hide
                                                                 -1)
                                                                (("1"
                                                                  (name
                                                                   "Bfun2"
                                                                   "LAMBDA (iz: nat): IF iz < i THEN 0 ELSE Bfun(iz - i) ENDIF")
                                                                  (("1"
                                                                    (replace
                                                                     -1)
                                                                    (("1"
                                                                      (case
                                                                       "sigma(0,i-1,Afun) = 0")
                                                                      (("1"
                                                                        (replace
                                                                         -1)
                                                                        (("1"
                                                                          (lemma
                                                                           "sigma_restrict_eq")
                                                                          (("1"
                                                                            (inst
                                                                             -
                                                                             "Bfun2"
                                                                             "Afun"
                                                                             "nn"
                                                                             "i")
                                                                            (("1"
                                                                              (assert)
                                                                              (("1"
                                                                                (hide
                                                                                 2)
                                                                                (("1"
                                                                                  (expand
                                                                                   "restrict")
                                                                                  (("1"
                                                                                    (decompose-equality
                                                                                     +)
                                                                                    (("1"
                                                                                      (lift-if)
                                                                                      (("1"
                                                                                        (ground)
                                                                                        (("1"
                                                                                          (replace
                                                                                           -3
                                                                                           :dir
                                                                                           rl)
                                                                                          (("1"
                                                                                            (replace
                                                                                             -4
                                                                                             :dir
                                                                                             rl)
                                                                                            (("1"
                                                                                              (replace
                                                                                               -2
                                                                                               :dir
                                                                                               rl)
                                                                                              (("1"
                                                                                                (assert)
                                                                                                (("1"
                                                                                                  (lift-if)
                                                                                                  (("1"
                                                                                                    (lift-if)
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      (("1"
                                                                                                        (ground)
                                                                                                        (("1"
                                                                                                          (replace
                                                                                                           -1)
                                                                                                          (("1"
                                                                                                            (case
                                                                                                             "i = 0")
                                                                                                            (("1"
                                                                                                              (replace
                                                                                                               -1)
                                                                                                              (("1"
                                                                                                                (assert)
                                                                                                                (("1"
                                                                                                                  (expand
                                                                                                                   "neg_power_fs")
                                                                                                                  (("1"
                                                                                                                    (expand
                                                                                                                     "C")
                                                                                                                    (("1"
                                                                                                                      (assert)
                                                                                                                      (("1"
                                                                                                                        (expand
                                                                                                                         "^")
                                                                                                                        (("1"
                                                                                                                          (expand
                                                                                                                           "expt")
                                                                                                                          (("1"
                                                                                                                            (assert)
                                                                                                                            nil
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil)
                                                                                                             ("2"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil)
                                                                                                         ("2"
                                                                                                          (replace
                                                                                                           -1)
                                                                                                          (("2"
                                                                                                            (case
                                                                                                             "x!2 = i")
                                                                                                            (("1"
                                                                                                              (replace
                                                                                                               -1)
                                                                                                              (("1"
                                                                                                                (expand
                                                                                                                 "neg_power_fs")
                                                                                                                (("1"
                                                                                                                  (expand
                                                                                                                   "C")
                                                                                                                  (("1"
                                                                                                                    (assert)
                                                                                                                    nil
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil)
                                                                                                             ("2"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil)
                                                                                                         ("3"
                                                                                                          (expand
                                                                                                           "neg_power_fs")
                                                                                                          (("3"
                                                                                                            (expand
                                                                                                             "C")
                                                                                                            (("3"
                                                                                                              (hide
                                                                                                               -)
                                                                                                              (("3"
                                                                                                                (lemma
                                                                                                                 "expt_plus")
                                                                                                                (("3"
                                                                                                                  (inst
                                                                                                                   -
                                                                                                                   "x!2-i"
                                                                                                                   "i"
                                                                                                                   "x!1")
                                                                                                                  (("1"
                                                                                                                    (assert)
                                                                                                                    nil
                                                                                                                    nil)
                                                                                                                   ("2"
                                                                                                                    (flatten)
                                                                                                                    (("2"
                                                                                                                      (replace
                                                                                                                       -1)
                                                                                                                      (("2"
                                                                                                                        (expand
                                                                                                                         "^")
                                                                                                                        (("2"
                                                                                                                          (expand
                                                                                                                           "expt")
                                                                                                                          (("2"
                                                                                                                            (assert)
                                                                                                                            nil
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (lemma
                                                                         "sigma_zero")
                                                                        (("2"
                                                                          (inst
                                                                           -
                                                                           "i-1"
                                                                           "0")
                                                                          (("2"
                                                                            (lemma
                                                                             "sigma_restrict_eq")
                                                                            (("2"
                                                                              (inst
                                                                               -
                                                                               "(LAMBDA (i: nat): 0)"
                                                                               "Afun"
                                                                               "i-1"
                                                                               "0")
                                                                              (("2"
                                                                                (assert)
                                                                                (("2"
                                                                                  (hide
                                                                                   (2
                                                                                    3))
                                                                                  (("2"
                                                                                    (decompose-equality
                                                                                     +)
                                                                                    (("2"
                                                                                      (expand
                                                                                       "restrict")
                                                                                      (("2"
                                                                                        (lift-if)
                                                                                        (("2"
                                                                                          (ground)
                                                                                          (("2"
                                                                                            (replace
                                                                                             -3
                                                                                             :dir
                                                                                             rl)
                                                                                            (("2"
                                                                                              (assert)
                                                                                              (("2"
                                                                                                (lift-if)
                                                                                                (("2"
                                                                                                  (ground)
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (skeep)
                                                                    (("2"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (decompose-equality +)
                                                nil
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (skeep)
                                            (("2" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (skeep)
                                      (("2" (assertnil nil))
                                      nil)
                                     ("3"
                                      (skeep)
                                      (("3" (assertnil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (assertnil nil))
                nil))
              nil)
             ("2" (hide 2)
              (("2" (skeep)
                (("2" (case "n>0")
                  (("1" (inst - "n"nil nil)
                   ("2" (case "n = 0")
                    (("1" (replace -1)
                      (("1" (hide-all-but 2)
                        (("1" (decompose-equality +)
                          (("1" (expand "^")
                            (("1" (expand "expt")
                              (("1"
                                (expand "polynomial")
                                (("1"
                                  (expand "sigma")
                                  (("1"
                                    (assert)
                                    (("1"
                                      (expand "neg_power_fs")
                                      (("1"
                                        (expand "C")
                                        (("1"
                                          (assert)
                                          (("1"
                                            (expand "^")
                                            (("1"
                                              (expand "expt")
                                              (("1" (assertnil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (assertnil nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (skeep) (("2" (assertnil nil)) nil)
       ("3" (skeep) (("3" (assertnil nil)) nil))
      nil))
    nil)
   ((real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (nzrat_times_nzrat_is_nzrat application-judgement "nzrat" rationals
     nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (<= const-decl "bool" reals nil)
    (nn skolem-const-decl "above(i - 1)" bernstein_polynomials nil)
    (above nonempty-type-eq-decl nil integers nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (> const-decl "bool" reals nil)
    (i skolem-const-decl "nat" bernstein_polynomials nil)
    (< const-decl "bool" reals nil)
    (NOT const-decl "[bool -> bool]" booleans 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)
    (Bern const-decl "real" bernstein_polynomials nil)
    (sequence type-eq-decl nil sequences nil)
    (polynomial const-decl "[real -> real]" polynomials nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (/= const-decl "boolean" notequal nil)
    (^ const-decl "real" exponentiation nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (C const-decl "posnat" binomial 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)
    (neg_power_polynomial formula-decl nil polynomials nil)
    (n skolem-const-decl "nat" bernstein_polynomials nil)
    (T_low type-eq-decl nil sigma nil)
    (T_high type-eq-decl nil sigma nil)
    (sigma_scal formula-decl nil sigma 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)
    (sigma def-decl "real" sigma nil)
    (sigma_restrict_eq formula-decl nil sigma nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (restrict const-decl "[T -> real]" sigma nil)
    (x!1 skolem-const-decl "real" bernstein_polynomials nil)
    (nzreal nonempty-type-eq-decl nil reals nil)
    (nnrat_times_nnrat_is_nnrat application-judgement "nonneg_rat"
     rationals nil)
    (expt_plus formula-decl nil exponentiation nil)
    (factorial_0 formula-decl nil factorial "ints/")
    (nzint_times_nzint_is_nzint application-judgement "nzint" integers
     nil)
    (expt def-decl "real" exponentiation nil)
    (posrat_times_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (nzreal_expt application-judgement "nzreal" exponentiation nil)
    (int_expt application-judgement "int" exponentiation nil)
    (posrat_div_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (even_minus_even_is_even application-judgement "even_int" integers
     nil)
    (int_exp application-judgement "int" exponentiation nil)
    (sigma_0_neg formula-decl nil sigma_nat nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (sigma_nnreal application-judgement "nnreal" sigma_nat nil)
    (sigma_nat application-judgement "nat" sigma_nat nil)
    (sigma_zero formula-decl nil sigma nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (sigma_split formula-decl nil sigma nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (sigma_shift_T2 formula-decl nil sigma nil)
    (nzreal_exp application-judgement "nzreal" exponentiation nil)
    (rat_exp application-judgement "rat" exponentiation nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (neg_power_fs const-decl "[nat -> int]" polynomials nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (real_minus_real_is_real application-judgement "real" reals nil))
   nil))
 (Bernstein_Recursion_TCC1 0
  (Bernstein_Recursion_TCC1-1 nil 3479211177 ("" (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_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   nil))
 (Bernstein_Recursion_TCC2 0
  (Bernstein_Recursion_TCC2-1 nil 3479211177 ("" (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_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   nil))
 (Bernstein_Recursion_TCC3 0
  (Bernstein_Recursion_TCC3-1 nil 3479211177 ("" (subtype-tcc) nil nil)
   nil nil))
 (Bernstein_Recursion_TCC4 0
  (Bernstein_Recursion_TCC4-1 nil 3479211177 ("" (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_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   nil))
 (Bernstein_Recursion 0
  (Bernstein_Recursion-1 nil 3479211177
   ("" (skeep)
    (("" (case "C(k,r) = C(k-1,r) + C(k-1,r-1)")
      (("1" (mult-by -1 "x^r*(1-x)^(k-r)")
        (("1" (expand "Bern")
          (("1" (case "x^r = x^(r-1)*x")
            (("1" (case "(1-x)^(k-r) = (1-x)*(1-x)^(k-r-1)")
              (("1" (assertnil nil)
               ("2" (expand "^" 1)
                (("2" (assert)
                  (("2" (expand "expt" 1 1) (("2" (assertnil nil))
                    nil))
                  nil))
                nil)
               ("3" (assertnil nil))
              nil)
             ("2" (expand "^" 1)
              (("2" (expand "expt" 1 1) (("2" (assertnil nil)) nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (hide 2)
        (("2" (lemma "C_n_plus_1")
          (("2" (inst - "k-1" "r") (("2" (assertnil nil)) nil)) nil))
        nil)
       ("3" (assertnil nil) ("4" (assertnil nil)
       ("5" (assertnil nil))
      nil))
    nil)
   ((- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (C const-decl "posnat" binomial 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 "bool" reals 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)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (Bern const-decl "real" bernstein_polynomials nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (expt def-decl "real" exponentiation nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (/= const-decl "boolean" notequal nil)
    (x skolem-const-decl "real" bernstein_polynomials nil)
    (k skolem-const-decl "posnat" bernstein_polynomials nil)
    (r skolem-const-decl "posnat" bernstein_polynomials nil)
    (^ const-decl "real" exponentiation nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (both_sides_times1_imp formula-decl nil extra_real_props nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (C_n_plus_1 formula-decl nil binomial nil))
   shostak))
 (Bern_nonnegative 0
  (Bern_nonnegative-1 nil 3479211589
   ("" (skeep)
    (("" (skeep)
      (("" (expand "Bern")
        (("" (typepred "C(nn,i)")
          (("" (lemma "nnreal_expt")
            (("" (inst-cp - "i" "x")
              (("1" (inst - "nn-i" "1-x")
                (("1" (expand "^")
                  (("1" (assert)
                    (("1" (lemma "nnreal_times_nnreal_is_nnreal")
                      (("1" (inst?)
                        (("1" (lemma "nnreal_times_nnreal_is_nnreal")
                          (("1" (inst?) nil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (assertnil nil))
                nil)
               ("2" (assertnil nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((above nonempty-type-eq-decl nil integers nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (C const-decl "posnat" binomial nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (<= const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (> const-decl "bool" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (x skolem-const-decl "real" bernstein_polynomials nil)
    (nnreal type-eq-decl nil real_types nil)
    (^ const-decl "real" exponentiation nil)
    (nnreal_times_nnreal_is_nnreal judgement-tcc nil real_types nil)
    (nn skolem-const-decl "above(i - 1)" bernstein_polynomials nil)
    (i skolem-const-decl "nat" bernstein_polynomials nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (expt def-decl "real" exponentiation 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_times_real_is_real application-judgement "real" reals nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (nnreal_expt judgement-tcc nil exponentiation nil)
    (Bern const-decl "real" bernstein_polynomials nil))
   shostak))
 (Bern_positive 0
  (Bern_positive-1 nil 3479211969
   ("" (skeep)
    (("" (skeep)
      (("" (expand "Bern")
        (("" (typepred "C(nn,i)")
          (("" (lemma "posreal_expt")
            (("" (inst-cp - "i" "x")
              (("1" (inst - "nn-i" "1-x")
                (("1" (expand "^")
                  (("1" (assert)
                    (("1" (lemma "posreal_times_posreal_is_posreal")
                      (("1" (inst?)
                        (("1"
                          (case "C(nn, i) * expt((1 - x), (nn - i)) > 0")
                          (("1" (assertnil nil)
                           ("2" (hide 2)
                            (("2"
                              (lemma
                               "posreal_times_posreal_is_posreal")
                              (("2" (inst?) nil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (assertnil nil))
                nil)
               ("2" (assertnil nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((above nonempty-type-eq-decl nil integers nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (C const-decl "posnat" binomial nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (<= const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (> const-decl "bool" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (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)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (x skolem-const-decl "real" bernstein_polynomials nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (^ const-decl "real" exponentiation nil)
    (posreal_times_posreal_is_posreal judgement-tcc nil real_types nil)
    (nn skolem-const-decl "above(i - 1)" bernstein_polynomials nil)
    (i skolem-const-decl "nat" bernstein_polynomials nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (expt def-decl "real" exponentiation nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (posreal_expt judgement-tcc nil exponentiation nil)
    (Bern const-decl "real" bernstein_polynomials nil))
   nil))
 (Bernstein_degree_raise_TCC1 0
  (Bernstein_degree_raise_TCC1-1 nil 3479477346
   ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (> const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (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))
   nil))
 (Bernstein_degree_raise_TCC2 0
  (Bernstein_degree_raise_TCC2-1 nil 3479477346
   ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (> const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (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))
   nil))
 (Bernstein_degree_raise 0
  (Bernstein_degree_raise-1 nil 3479213227
   ("" (skeep)
    ((""
      (case "C(k-1,p) = ((k-p)/k)*C(k,p) AND ((k-p)/k)*C(k,p) = ((p+1)/k)*C(k,p+1)")
      (("1" (flatten)
        (("1" (mult-by -1 "x^p*(1-x)^(k-p-1)")
          (("1" (mult-by -2 "x^(p+1)*(1-x)^(k-p-1)")
            (("1" (expand "Bern")
              (("1" (case "(1-x)^(k-p) = (1-x)*(1-x)^(k-p-1)")
                (("1" (replace -1 1)
                  (("1" (hide -1)
                    (("1" (case "x^(p+1) = x*x^p")
                      (("1" (assertnil nil)
                       ("2" (expand "^" 1)
                        (("2" (expand "expt" 1 1)
                          (("2" (propax) nil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (expand "^" 1)
                  (("2" (assert)
                    (("2" (expand "expt" 1 1) (("2" (assertnil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (hide 2)
        (("2" (split)
          (("1" (expand "C")
            (("1" (expand "factorial" 1 4)
              (("1" (expand "factorial" 1 6)
                (("1" (assert) (("1" (cross-mult 1) nil nil)) nil))
                nil))
              nil))
            nil)
           ("2" (expand "C")
            (("2" (expand "factorial" 1 3)
              (("2" (assert)
                (("2" (expand "factorial" 1 7)
                  (("2" (cross-mult 1) nil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("3" (assertnil nil) ("4" (assertnil nil)
       ("5" (assertnil nil) ("6" (assertnil nil))
      nil))
    nil)
   ((+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/= const-decl "boolean" notequal nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (C const-decl "posnat" binomial 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 "bool" reals nil) (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (number nonempty-type-decl nil numbers nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (posrat_times_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (rat_times_rat_is_rat application-judgement "rat" rationals nil)
    (rat_div_nzrat_is_rat application-judgement "rat" rationals 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)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (both_sides_times1_imp formula-decl nil extra_real_props nil)
    (^ const-decl "real" exponentiation nil)
    (k skolem-const-decl "posnat" bernstein_polynomials nil)
    (p skolem-const-decl "nat" bernstein_polynomials nil)
    (x skolem-const-decl "real" bernstein_polynomials nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (posrat_div_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (Bern const-decl "real" bernstein_polynomials nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (expt def-decl "real" exponentiation nil)
    (factorial def-decl "posnat" factorial "ints/")
    (nzrat_div_nzrat_is_nzrat application-judgement "nzrat" rationals
     nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (div_cancel4 formula-decl nil real_props nil)
    (div_cancel3 formula-decl nil real_props nil)
    (times_div2 formula-decl nil real_props nil)
    (times_div1 formula-decl nil real_props nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (nnrat_times_nnrat_is_nnrat application-judgement "nonneg_rat"
     rationals nil))
   shostak))
 (degree_raise_TCC1 0
  (degree_raise_TCC1-1 nil 3480405695 ("" (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)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (degree_raise_TCC2 0
  (degree_raise_TCC2-1 nil 3480405695 ("" (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)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (degree_raise_TCC3 0
  (degree_raise_TCC3-1 nil 3480405695 ("" (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)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (degree_raise_TCC4 0
  (degree_raise_TCC4-1 nil 3480405695 ("" (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)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil))
   nil))
 (degree_raise_power_TCC1 0
  (degree_raise_power_TCC1-1 nil 3480410715 ("" (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)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (degree_raise_power_TCC2 0
  (degree_raise_power_TCC2-1 nil 3480410715
   ("" (termination-tcc) nil nilnil nil))
 (Bernstein_index_degree_raise_TCC1 0
  (Bernstein_index_degree_raise_TCC1-1 nil 3479472990
   ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (> const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (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))
   nil))
 (Bernstein_index_degree_raise_TCC2 0
  (Bernstein_index_degree_raise_TCC2-1 nil 3479476400
   ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (> const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     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))
   nil))
 (Bernstein_index_degree_raise 0
  (RWBf "RWB - (field 1) on leaf removed to prevent infinite loop"
   3508838184
   ("" (skeep)
    (("" (case "k > p")
      (("1" (hide -2)
        (("1" (lemma "Bernstein_Recursion")
          (("1" (inst - "k+1" "p+1" "x")
            (("1" (name "A" "1-x")
              (("1" (replace -1)
                (("1" (assert)
                  (("1"
                    (case "A*Bern(1+p,k)(x) = (C(k,p+1)/C(k+1,p+1))*Bern(1+p,1+k)(x)")
                    (("1" (replace -1)
                      (("1" (hide -1)
                        (("1" (expand "C" -2)
                          (("1" (expand "factorial" -2 4)
                            (("1" (expand "factorial" -2 7)
                              (("1"
                                (name "const1" "Bern(p,k)(x)")
                                (("1"
                                  (replace -1)
                                  (("1"
                                    (name "const2" "Bern(1+p,1+k)(x)")
                                    (("1"
                                      (replace -1)
                                      (("1"
                                        (name "const3" "factorial(k)")
                                        (("1"
                                          (replace -1)
                                          (("1"
                                            (name
                                             "const4"
                                             "factorial(1+p)")
                                            (("1"
                                              (replace -1)
                                              (("1"
                                                (name
                                                 "const5"
                                                 "factorial(-1-p+k)")
                                                (("1"
                                                  (replace -1)
                                                  (("1"
                                                    (hide -1)
                                                    (("1"
                                                      (hide -1)
                                                      (("1"
                                                        (hide -1)
                                                        (("1"
                                                          (hide -1)
                                                          (("1"
                                                            (hide -1)
                                                            (("1"
                                                              (case
                                                               "(const3 / (const4 * const5) /
                                                              ((const3 + const3 * k) /
                                                                (const4 * const5 * k - const4 * const5 * p))) = (k-p)/(1+k)")
                                                              (("1"
                                                                (replace
                                                                 -1)
                                                                (("1"
                                                                  (hide
                                                                   -1)
                                                                  (("1"
                                                                    (both-sides
                                                                     "-"
                                                                     "((k-p)/(1+k))*const2"
                                                                     -2)
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (replace
                                                                         -2
                                                                         :dir
                                                                         rl)
                                                                        (("1"
                                                                          (field
                                                                           1)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (hide
                                                                 2)
                                                                (("2"
                                                                  (name
                                                                   "apz1"
                                                                   "(const3 / (const4 * const5) /
        ((const3 + const3 * k) /
          (const4 * const5 * k - const4 * const5 * p)))")
                                                                  (("2"
                                                                    (replace
                                                                     -1)
                                                                    (("2"
                                                                      (mult-by
                                                                       1
                                                                       "const4*const5")
                                                                      (("2"
                                                                        (case
                                                                         "apz1*(const4*const5) = 1/((1 + k) /
          (const4 * const5 * k - const4 * const5 * p))")
                                                                        (("1"
                                                                          (replace
                                                                           -1)
                                                                          (("1"
                                                                            (hide
                                                                             -1)
                                                                            (("1"
                                                                              (hide
                                                                               -1)
                                                                              (("1"
                                                                                (field
                                                                                 1)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (hide
                                                                           2)
                                                                          (("2"
                                                                            (cross-mult
                                                                             1)
                                                                            (("2"
                                                                              (replace
                                                                               -1
                                                                               :dir
                                                                               rl)
                                                                              (("2"
                                                                                (field
                                                                                 1)
                                                                                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" (hide (-2 2))
                      (("2" (expand "Bern")
                        (("2" (case "A*(1-x)^(k-p-1) = (1-x)^(k-p)")
                          (("1" (assertnil nil)
                           ("2" (replace -1 :dir rl)
                            (("2" (expand "^")
                              (("2"
                                (expand "expt" 1 3)
                                (("2" (propax) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (case "k = p")
        (("1" (replace -1)
          (("1" (hide -1)
            (("1" (hide -1)
              (("1" (hide 1)
                (("1" (lemma "Bern_top")
                  (("1" (inst-cp - "p" "x")
                    (("1" (inst - "p+1" "x")
                      (("1" (replace -1)
                        (("1" (hide -1)
                          (("1" (replace -1)
                            (("1" (hide -1)
                              (("1"
                                (expand "^")
                                (("1"
                                  (expand "expt" 1 2)
                                  (("1" (field) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (assertnil nil))
        nil))
      nil))
    nil)
   ((nat nonempty-type-eq-decl nil naturalnumbers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (> const-decl "bool" reals 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)
    (Bernstein_Recursion formula-decl nil bernstein_polynomials nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (^ const-decl "real" exponentiation nil)
    (expt def-decl "real" exponentiation nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (nzrat_div_nzrat_is_nzrat application-judgement "nzrat" rationals
     nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (rat_div_nzrat_is_rat application-judgement "rat" rationals nil)
    (rat_minus_rat_is_rat application-judgement "rat" rationals nil)
    (posint nonempty-type-eq-decl nil integers nil)
    (both_sides_times1 formula-decl nil real_props nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (div_cancel2 formula-decl nil real_props nil)
    (bijective? const-decl "bool" functions nil)
    (id const-decl "(bijective?[T, T])" identity nil)
    (TRUE const-decl "bool" booleans nil)
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (times_div2 formula-decl nil real_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (nzrat nonempty-type-eq-decl nil rationals nil)
    (div_div2 formula-decl nil real_props nil)
    (cross_mult formula-decl nil real_props nil)
    (rat_plus_rat_is_rat application-judgement "rat" rationals nil)
    (div_cancel3 formula-decl nil real_props nil)
    (times_div1 formula-decl nil real_props nil)
    (div_cancel4 formula-decl nil real_props nil)
    (rat_times_rat_is_rat application-judgement "rat" rationals nil)
    (div_div1 formula-decl nil real_props nil)
    (nzrat_times_nzrat_is_nzrat application-judgement "nzrat" rationals
     nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (factorial def-decl "posnat" factorial "ints/")
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (above nonempty-type-eq-decl nil integers nil)
    (Bern const-decl "real" bernstein_polynomials nil)
    (/= const-decl "boolean" notequal nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (<= const-decl "bool" reals nil)
    (C const-decl "posnat" binomial nil)
    (posrat_div_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (Bern_top formula-decl nil bernstein_polynomials nil)
    (div_simp formula-decl nil real_props nil))
   shostak)
  (Bernstein_index_degree_raise-1 nil 3479472990
   ("" (skeep)
    (("" (case "k > p")
      (("1" (hide -2)
        (("1" (lemma "Bernstein_Recursion")
          (("1" (inst - "k+1" "p+1" "x")
            (("1" (name "A" "1-x")
              (("1" (replace -1)
                (("1" (assert)
                  (("1"
                    (case "A*Bern(1+p,k)(x) = (C(k,p+1)/C(k+1,p+1))*Bern(1+p,1+k)(x)")
                    (("1" (replace -1)
                      (("1" (hide -1)
                        (("1" (expand "C" -2)
                          (("1" (expand "factorial" -2 4)
                            (("1" (expand "factorial" -2 7)
                              (("1"
                                (name "const1" "Bern(p,k)(x)")
                                (("1"
                                  (replace -1)
                                  (("1"
                                    (name "const2" "Bern(1+p,1+k)(x)")
                                    (("1"
                                      (replace -1)
                                      (("1"
                                        (name "const3" "factorial(k)")
                                        (("1"
                                          (replace -1)
                                          (("1"
                                            (name
                                             "const4"
                                             "factorial(1+p)")
                                            (("1"
                                              (replace -1)
                                              (("1"
                                                (name
                                                 "const5"
                                                 "factorial(-1-p+k)")
                                                (("1"
                                                  (replace -1)
                                                  (("1"
                                                    (hide -1)
                                                    (("1"
                                                      (hide -1)
                                                      (("1"
                                                        (hide -1)
                                                        (("1"
                                                          (hide -1)
                                                          (("1"
                                                            (hide -1)
                                                            (("1"
                                                              (case
                                                               "(const3 / (const4 * const5) /
                                        ((const3 + const3 * k) /
                                          (const4 * const5 * k - const4 * const5 * p))) = (k-p)/(1+k)")
                                                              (("1"
                                                                (replace
                                                                 -1)
                                                                (("1"
                                                                  (hide
                                                                   -1)
                                                                  (("1"
                                                                    (both-sides
                                                                     "-"
                                                                     "((k-p)/(1+k))*const2"
                                                                     -2)
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (replace
                                                                         -2
                                                                         :dir
                                                                         rl)
                                                                        (("1"
                                                                          (field
                                                                           1)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (hide
                                                                 2)
                                                                (("2"
                                                                  (field
                                                                   1)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide (-2 2))
                      (("2" (expand "Bern")
                        (("2" (case "A*(1-x)^(k-p-1) = (1-x)^(k-p)")
                          (("1" (assertnil nil)
                           ("2" (replace -1 :dir rl)
                            (("2" (expand "^")
                              (("2"
                                (expand "expt" 1 3)
                                (("2" (propax) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (case "k = p")
        (("1" (replace -1)
          (("1" (hide -1)
            (("1" (hide -1)
              (("1" (hide 1)
                (("1" (lemma "Bern_top")
                  (("1" (inst-cp - "p" "x")
                    (("1" (inst - "p+1" "x")
                      (("1" (replace -1)
                        (("1" (hide -1)
                          (("1" (replace -1)
                            (("1" (hide -1)
                              (("1"
                                (expand "^")
                                (("1"
                                  (expand "expt" 1 2)
                                  (("1" (field) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (assertnil nil))
        nil))
      nil))
    nil)
   ((factorial def-decl "posnat" factorial "ints/")
    (C const-decl "posnat" binomial nil))
   shostak))
 (Bernstein_partition_of_unity_TCC1 0
  (Bernstein_partition_of_unity_TCC1-1 nil 3479214531
   ("" (subtype-tcc) nil nilnil nil))
 (Bernstein_partition_of_unity_TCC2 0
  (Bernstein_partition_of_unity_TCC2-1 nil 3479214531
   ("" (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)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (Bernstein_partition_of_unity 0
  (Bernstein_partition_of_unity-1 nil 3479214531
   ("" (skeep)
    (("" (expand "Bern")
      (("" (lemma "binomial_theorem")
        (("" (inst - "p" "x" "(1-x)")
          (("" (replace -1 :dir rl)
            (("" (hide -1)
              (("" (assert) (("" (rewrite "expt_1i"nil nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((Bern const-decl "real" bernstein_polynomials nil)
    (real_minus_real_is_real application-judgement "real" reals 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)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (expt_1i formula-decl nil exponentiation nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (binomial_theorem formula-decl nil polynomials nil))
   shostak))
 (Bern_le_1 0
  (Bern_le_1-1 nil 3479546101
   ("" (skeep)
    (("" (skeep)
      (("" (lemma "Bernstein_partition_of_unity")
        (("" (inst - "nn" "x")
          ((""
            (name "AA"
                  "LAMBDA (i: nat): IF i > nn THEN 0 ELSE Bern(i, nn)(x) ENDIF")
            (("1" (case "FORALL (ijk:nat): AA(ijk)>=0")
              (("1" (replace -2)
                (("1" (lemma "sigma_split")
                  (("1" (inst - "AA" "nn" "0" "i-1")
                    (("1" (assert)
                      (("1" (replace -1)
                        (("1" (hide -1)
                          (("1" (lemma "sigma_split")
                            (("1" (inst - "AA" "nn" "i" "i")
                              (("1"
                                (assert)
                                (("1"
                                  (replace -1)
                                  (("1"
                                    (hide -1)
                                    (("1"
                                      (label "Ann" -1)
                                      (("1"
                                        (hide "Ann")
                                        (("1"
                                          (expand "sigma" -2 3)
                                          (("1"
                                            (lemma "sigma_le")
                                            (("1"
                                              (inst
                                               -
                                               "lambda (ij: nat): 0"
                                               "AA"
                                               "i-1"
                                               "0")
                                              (("1"
                                                (split -1)
                                                (("1"
                                                  (lemma "sigma_le")
                                                  (("1"
                                                    (inst
                                                     -
                                                     "lambda (ij: nat): 0"
                                                     "AA"
                                                     "nn"
                                                     "1+i")
                                                    (("1"
                                                      (split -1)
                                                      (("1"
                                                        (lemma
                                                         "sigma_zero")
                                                        (("1"
                                                          (inst
                                                           -
                                                           "nn"
                                                           "1+i")
                                                          (("1"
                                                            (lemma
                                                             "sigma_zero")
                                                            (("1"
                                                              (inst
                                                               -
                                                               "i-1"
                                                               "0")
                                                              (("1"
                                                                (expand
                                                                 "sigma"
                                                                 -6
                                                                 3)
                                                                (("1"
                                                                  (replace
                                                                   -5
                                                                   :dir
                                                                   rl)
                                                                  (("1"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (reveal "Ann")
                                                        (("2"
                                                          (skosimp*)
                                                          (("2"
                                                            (inst-cp
                                                             -
                                                             "n!1")
                                                            (("2"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (reveal "Ann")
                                                  (("2"
                                                    (skosimp*)
                                                    (("2"
                                                      (inst-cp - "n!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)
               ("2" (skeep)
                (("2" (replace -1 :dir rl)
                  (("2" (assert)
                    (("2" (lift-if)
                      (("2" (ground)
                        (("2" (lemma "Bern_nonnegative")
                          (("2" (inst - "x")
                            (("2" (assert)
                              (("2" (inst - "ijk" "nn"nil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (assert)
              (("2" (skosimp*) (("2" (assertnil nil)) nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (> const-decl "bool" reals nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (above nonempty-type-eq-decl nil integers nil)
    (sigma_split formula-decl nil sigma nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (sigma def-decl "real" sigma nil)
    (sigma_nnreal application-judgement "nnreal" sigma_nat nil)
    (sigma_nat application-judgement "nat" sigma_nat nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (sigma_zero formula-decl nil sigma nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (subrange type-eq-decl nil integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (sigma_le formula-decl nil sigma nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (T_high type-eq-decl nil sigma nil)
    (T_low type-eq-decl nil sigma nil)
    (Bern_nonnegative formula-decl nil bernstein_polynomials nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (Bern const-decl "real" bernstein_polynomials nil)
    (Bernstein_partition_of_unity formula-decl nil
     bernstein_polynomials nil))
   shostak))
 (Bernstein_conversion_TCC1 0
  (Bernstein_conversion_TCC1-1 nil 3479457319
   ("" (subtype-tcc) nil nilnil nil))
 (Bernstein_conversion_TCC2 0
  (Bernstein_conversion_TCC2-1 nil 3479457319
   ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (> const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (real_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)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (Bernstein_conversion_TCC3 0
  (Bernstein_conversion_TCC3-1 nil 3479457319
   ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (> const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (real_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)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (Bernstein_conversion_TCC4 0
  (Bernstein_conversion_TCC4-1 nil 3479487738
   ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (> const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (real_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))
   nil))
 (Bernstein_conversion 0
  (Bernstein_conversion-1 nil 3479457319
   ("" (skeep)
    ((""
      (case "FORALL (nn: nat): x ^ nn =
                            sigma(nn, k-p+nn,
                                  LAMBDA (i: nat):
                                    IF i < nn OR i > k-p+nn THEN 0
                                    ELSE (C(i, nn) / C(k-p+nn, nn)) * Bern(i, k-p+nn)(x)
                                    ENDIF)")
      (("1" (inst - "p") (("1" (assertnil nil)) nil)
       ("2" (hide 2)
        (("2" (induct "nn")
          (("1" (expand "^")
            (("1" (expand "expt")
              (("1" (case "k = p")
                (("1" (replace -1)
                  (("1" (assert)
                    (("1" (expand "sigma")
                      (("1" (assert)
                        (("1" (expand "C")
                          (("1" (expand "Bern")
                            (("1" (expand "^")
                              (("1"
                                (expand "expt")
                                (("1"
                                  (expand "C")
                                  (("1" (assertnil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (lemma "Bernstein_partition_of_unity")
                  (("2" (inst - "k-p" "x")
                    (("1" (lemma "sigma_restrict_eq")
                      (("1"
                        (inst - "LAMBDA (i: nat):
                                   IF i > k - p THEN 0
                                   ELSE (C(i, 0) / C(k - p, 0)) * Bern(i, k - p)(x)
                                   ENDIF" "LAMBDA (i: nat):
                                  IF i > k - p THEN 0 ELSE Bern(i, k - p)(x) ENDIF"
                         "k-p" "0")
                        (("1" (assert)
                          (("1" (hide 3)
                            (("1" (hide -1)
                              (("1"
                                (decompose-equality)
                                (("1"
                                  (expand "restrict")
                                  (("1"
                                    (lift-if)
                                    (("1"
                                      (ground)
                                      (("1"
                                        (expand "C")
                                        (("1" (assertnil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (skeep)
                                  (("2" (assertnil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (skeep) (("2" (assertnil nil)) nil)
                         ("3" (skeep) (("3" (assertnil nil)) nil)
                         ("4" (skeep) (("4" (assertnil nil)) nil))
                        nil))
                      nil)
                     ("2" (assertnil nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (skeep)
            (("2"
              (name "F" "LAMBDA (i: nat):
               IF i < j OR i > k - p + j THEN 0
               ELSE (C(i, j) / C(k - p + j, j)) * Bern(i, k - p + j)(x)
               ENDIF")
              (("1" (replace -1)
                (("1"
                  (name "G" "LAMBDA (i: nat):
               IF i < j + 1 OR i > k - p + (j + 1) THEN 0
               ELSE (C(i, j + 1) / C(k - p + (j + 1), j + 1)) *
                     Bern(i, k - p + (j + 1))(x)
               ENDIF")
                  (("1" (replace -1)
                    (("1" (mult-by -3 "x")
                      (("1" (expand "^")
                        (("1" (expand "expt" +)
                          (("1" (replace -1)
                            (("1" (hide -1)
                              (("1"
                                (lemma "sigma_scal")
                                (("1"
                                  (inst - "F" "x" "j-p+k" "j")
                                  (("1"
                                    (replace -1 :dir rl)
                                    (("1"
                                      (hide -1)
                                      (("1"
                                        (name
                                         "H"
                                         "LAMBDA (i: nat): x * F(i)")
                                        (("1"
                                          (replace -1)
                                          (("1"
                                            (lemma "sigma_shift_T2")
                                            (("1"
                                              (inst
                                               -
                                               "H"
                                               "j-p+k+1"
                                               "1+j"
                                               "-1")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (replace -1)
                                                  (("1"
                                                    (lemma
                                                     "sigma_restrict_eq")
                                                    (("1"
                                                      (inst?)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (hide 2)
                                                          (("1"
                                                            (decompose-equality)
                                                            (("1"
                                                              (expand
                                                               "restrict")
                                                              (("1"
                                                                (lift-if)
                                                                (("1"
                                                                  (ground)
                                                                  (("1"
                                                                    (hide
                                                                     -1)
                                                                    (("1"
                                                                      (replace
                                                                       -1
                                                                       :dir
                                                                       rl)
                                                                      (("1"
                                                                        (hide
                                                                         -1)
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (replace
                                                                             -1
                                                                             :dir
                                                                             rl)
                                                                            (("1"
                                                                              (assert)
                                                                              (("1"
                                                                                (hide
                                                                                 -1)
                                                                                (("1"
                                                                                  (replace
                                                                                   -1
                                                                                   :dir
                                                                                   rl)
                                                                                  (("1"
                                                                                    (assert)
                                                                                    (("1"
                                                                                      (hide
                                                                                       -1)
                                                                                      (("1"
                                                                                        (lemma
                                                                                         "Bernstein_index_degree_raise")
                                                                                        (("1"
                                                                                          (inst
                                                                                           -
                                                                                           "j-p+k"
                                                                                           "x!1-1"
                                                                                           "x")
                                                                                          (("1"
                                                                                            (assert)
                                                                                            (("1"
                                                                                              (mult-by
                                                                                               -1
                                                                                               "(C(x!1 - 1, j) / C(j - p + k, j))")
                                                                                              (("1"
                                                                                                (replace
                                                                                                 -1)
                                                                                                (("1"
                                                                                                  (hide
                                                                                                   -1)
                                                                                                  (("1"
                                                                                                    (case
                                                                                                     "(x!1 / (1 - p + j + k)) * 
       (C(x!1 - 1, j) / C(j - p + k, j))
       =
       (C(x!1, 1 + j) / C(1 - p + j + k, 1 + j)) ")
                                                                                                    (("1"
                                                                                                      (mult-by
                                                                                                       -1
                                                                                                       "Bern(x!1,1-p+j+k)(x)")
                                                                                                      (("1"
                                                                                                        (assert)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (hide
                                                                                                       4)
                                                                                                      (("2"
                                                                                                        (expand
                                                                                                         "C")
                                                                                                        (("2"
                                                                                                          (expand
                                                                                                           "factorial"
                                                                                                           1
                                                                                                           7)
                                                                                                          (("2"
                                                                                                            (cross-mult
                                                                                                             1)
                                                                                                            (("2"
                                                                                                              (field)
                                                                                                              (("2"
                                                                                                                (expand
                                                                                                                 "factorial"
                                                                                                                 1
                                                                                                                 2)
                                                                                                                (("2"
                                                                                                                  (propax)
                                                                                                                  nil
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (typepred
                                                                                             "x!1")
                                                                                            (("2"
                                                                                              (case
                                                                                               "NOT j = 0")
                                                                                              (("1"
                                                                                                (assert)
                                                                                                nil
                                                                                                nil)
                                                                                               ("2"
                                                                                                (replace
                                                                                                 -1)
                                                                                                (("2"
                                                                                                  (assert)
                                                                                                  (("2"
                                                                                                    (case
                                                                                                     "NOT x!1 = 0")
                                                                                                    (("1"
                                                                                                      (case
                                                                                                       "k = p")
                                                                                                      (("1"
                                                                                                        (replace
                                                                                                         -1)
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          (("1"
                                                                                                            (case
                                                                                                             "x!1 = 1")
                                                                                                            (("1"
                                                                                                              (replace
                                                                                                               -1)
                                                                                                              (("1"
                                                                                                                (assert)
                                                                                                                (("1"
                                                                                                                  (lemma
                                                                                                                   "Bern_top")
                                                                                                                  (("1"
                                                                                                                    (inst-cp
                                                                                                                     -
                                                                                                                     "0"
                                                                                                                     "x")
                                                                                                                    (("1"
                                                                                                                      (inst
                                                                                                                       -
                                                                                                                       "1"
                                                                                                                       "x")
                                                                                                                      (("1"
                                                                                                                        (replace
                                                                                                                         -1)
                                                                                                                        (("1"
                                                                                                                          (replace
                                                                                                                           -2)
                                                                                                                          (("1"
                                                                                                                            (expand
                                                                                                                             "^")
                                                                                                                            (("1"
                                                                                                                              (expand
                                                                                                                               "expt")
                                                                                                                              (("1"
                                                                                                                                (expand
                                                                                                                                 "expt")
                                                                                                                                (("1"
                                                                                                                                  (propax)
                                                                                                                                  nil
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil)
                                                                                                             ("2"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil)
                                                                                                       ("2"
                                                                                                        (assert)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (assert)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (flatten)
                                                (("2"
                                                  (inst + "0")
                                                  (("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (skeep) (("2" (assertnil nil)) nil)
                   ("3" (skeep) (("3" (assertnil nil)) nil)
                   ("4" (skeep) (("4" (assertnil nil)) nil)
                   ("5" (skeep) (("5" (assertnil nil)) nil))
                  nil))
                nil)
               ("2" (skeep) (("2" (assertnil nil)) nil)
               ("3" (skeep) (("3" (assertnil nil)) nil)
               ("4" (skeep) (("4" (assertnil nil)) nil)
               ("5" (skeep) (("5" (assertnil nil)) nil))
              nil))
            nil)
           ("3" (skeep) (("3" (assertnil nil)) nil)
           ("4" (skeep) (("4" (assertnil nil)) nil)
           ("5" (skeep) (("5" (assertnil nil)) nil)
           ("6" (skeep) (("6" (assertnil nil)) nil)
           ("7" (skeep) (("7" (assertnil nil)) nil))
          nil))
        nil)
       ("3" (skeep) (("3" (assertnil nil)) nil)
       ("4" (skeep) (("4" (assertnil nil)) nil)
       ("5" (skeep) (("5" (assertnil nil)) nil)
       ("6" (skeep) (("6" (assertnil nil)) nil)
       ("7" (skeep) (("7" (assertnil nil)) nil))
      nil))
    nil)
   ((Bern const-decl "real" bernstein_polynomials nil)
    (above nonempty-type-eq-decl nil integers nil)
    (C const-decl "posnat" binomial nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (< const-decl "bool" reals nil)
    (IF const-decl "[boolean, T, T -> T]" if_def 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 "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (sigma def-decl "real" sigma nil)
    (T_high type-eq-decl nil sigma nil)
    (T_low type-eq-decl nil sigma nil) (<= const-decl "bool" reals nil)
    (^ const-decl "real" exponentiation nil)
    (/= const-decl "boolean" notequal nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (p skolem-const-decl "nat" bernstein_polynomials nil)
    (k skolem-const-decl "posnat" bernstein_polynomials nil)
    (pred type-eq-decl nil defined_types nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (expt def-decl "real" exponentiation nil)
    (Bernstein_partition_of_unity formula-decl nil
     bernstein_polynomials nil)
    (sigma_restrict_eq formula-decl nil sigma nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (restrict const-decl "[T -> real]" sigma nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (posrat_div_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (posrat_times_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (factorial_0 formula-decl nil factorial "ints/")
    (sigma_0_neg formula-decl nil sigma_nat nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (both_sides_times1_imp formula-decl nil extra_real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (j skolem-const-decl "nat" bernstein_polynomials nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (factorial def-decl "posnat" factorial "ints/")
    (bijective? const-decl "bool" functions nil)
    (id const-decl "(bijective?[T, T])" identity nil)
    (TRUE const-decl "bool" booleans nil)
    (nnrat_plus_nnrat_is_nnrat application-judgement "nonneg_rat"
     rationals nil)
    (both_sides_times1 formula-decl nil real_props nil)
    (rat_plus_rat_is_rat application-judgement "rat" rationals nil)
    (rat_minus_rat_is_rat application-judgement "rat" rationals nil)
    (nnrat_times_nnrat_is_nnrat application-judgement "nonneg_rat"
     rationals nil)
    (div_cancel3 formula-decl nil real_props nil)
    (times_div2 formula-decl nil real_props nil)
    (nonzero_real nonempty-type-eq-decl nil reals nil)
    (times_div1 formula-decl nil real_props nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (nnrat_div_posrat_is_nnrat application-judgement "nonneg_rat"
     rationals nil)
    (rat_times_rat_is_rat application-judgement "rat" rationals nil)
    (rat_div_nzrat_is_rat application-judgement "rat" rationals nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (Bern_top formula-decl nil bernstein_polynomials nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (Bernstein_index_degree_raise formula-decl nil
     bernstein_polynomials nil)
    (sigma_shift_T2 formula-decl nil sigma nil)
    (sigma_scal formula-decl nil sigma nil))
   shostak))
 (Bernstein_conversion_2 0
  (Bernstein_conversion_2-1 nil 3479543185
   ("" (skeep)
    (("" (lemma "Bernstein_conversion")
      (("" (inst - "k" "p" "x")
        (("" (assert)
          (("" (case "p = 0")
            (("1" (assertnil nil)
             ("2" (lemma "sigma_split")
              (("2"
                (inst - "LAMBDA (i: nat):
               IF i < p OR i > k THEN 0
               ELSE (C(i, p) / C(k, p)) * Bern(i, k)(x)
               ENDIF" "k" "0" "p-1")
                (("1" (assert)
                  (("1" (replace -1)
                    (("1" (hide -1)
                      (("1" (lemma "sigma_restrict_eq")
                        (("1"
                          (inst - "LAMBDA (i: nat):
               IF i < p OR i > k THEN 0
               ELSE (C(i, p) / C(k, p)) * Bern(i, k)(x)
               ENDIF" "LAMBDA (i: nat):
               0" "p-1" "0")
                          (("1" (lemma "sigma_zero")
                            (("1" (inst - "p-1" "0")
                              (("1"
                                (assert)
                                (("1"
                                  (decompose-equality)
                                  (("1"
                                    (expand "restrict")
                                    (("1" (propax) nil nil))
                                    nil)
                                   ("2"
                                    (skosimp*)
                                    (("2" (assertnil nil))
                                    nil)
                                   ("3"
                                    (skosimp*)
                                    (("3" (assertnil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (skosimp*) (("2" (assertnil nil))
                            nil)
                           ("3" (skosimp*) (("3" (assertnil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (skosimp*) (("2" (assertnil nil)) nil)
                 ("3" (skosimp*) (("3" (assertnil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((Bernstein_conversion formula-decl nil bernstein_polynomials 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)
    (sigma_split formula-decl nil sigma nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (restrict const-decl "[T -> real]" sigma nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (sigma_nnreal application-judgement "nnreal" sigma_nat nil)
    (sigma_nat application-judgement "nat" sigma_nat nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (sigma_zero formula-decl nil sigma nil)
    (sigma_restrict_eq formula-decl nil sigma nil)
    (posrat_div_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (T_low type-eq-decl nil sigma nil)
    (T_high type-eq-decl nil sigma nil)
    (Bern const-decl "real" bernstein_polynomials nil)
    (above nonempty-type-eq-decl nil integers nil)
    (C const-decl "posnat" binomial nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/= const-decl "boolean" notequal nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (<= const-decl "bool" reals nil)
    (k skolem-const-decl "posnat" bernstein_polynomials nil)
    (p skolem-const-decl "nat" bernstein_polynomials nil)
    (< const-decl "bool" reals nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (nat nonempty-type-eq-decl nil naturalnumbers 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 "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))
 (Bern_poly_TCC1 0
  (Bern_poly_TCC1-1 nil 3479481006 ("" (subtype-tcc) nil nil)
   ((real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (Bern_poly_TCC2 0
  (Bern_poly_TCC2-1 nil 3479481006 ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (>= const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (Bern_poly_TCC3 0
  (Bern_poly_TCC3-1 nil 3479481006 ("" (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)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (degree_raise_id 0
  (degree_raise_id-1 nil 3480405695
   ("" (skeep)
    (("" (decompose-equality)
      (("" (expand "Bern_poly")
        (("" (name "mm" "b`index")
          (("" (replace -1)
            (("" (case "degree_raise(b)`index = mm+1")
              (("1" (replace -1)
                (("1"
                  (name "AA" "LAMBDA (i: nat):
                                                           IF i > mm THEN 0 ELSE b`bern_seq(i) * Bern(i, mm)(x!1) ENDIF")
                  (("1" (replace -1)
                    (("1"
                      (name "BB" "LAMBDA (i: nat):
                                                                      IF i > mm + 1 THEN 0
                                                                      ELSE degree_raise(b)`bern_seq(i) * Bern(i, mm + 1)(x!1)
                                                                      ENDIF")
                      (("1" (replace -1)
                        (("1"
                          (name "Aleft"
                                "LAMBDA (i:nat): IF i>mm THEN 0 ELSE b`bern_seq(i)*((mm+1-i)/(mm+1))*Bern(i,mm+1)(x!1) ENDIF")
                          (("1"
                            (name "Aright"
                                  "LAMBDA (i:nat): IF i > mm+1 OR i = 0 THEN 0 ELSE b`bern_seq(i-1)*(i/(mm+1))*Bern(i,mm+1)(x!1) ENDIF")
                            (("1" (case "NOT BB = Aleft+Aright")
                              (("1"
                                (hide 2)
                                (("1"
                                  (hide -4)
                                  (("1"
                                    (decompose-equality)
                                    (("1"
                                      (expand "+" +)
                                      (("1"
                                        (expand "BB" +)
                                        (("1"
                                          (expand "Aleft" +)
                                          (("1"
                                            (expand "Aright" +)
                                            (("1"
                                              (lift-if)
                                              (("1"
                                                (lift-if)
                                                (("1"
                                                  (lift-if)
                                                  (("1"
                                                    (lift-if)
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (ground)
                                                        (("1"
                                                          (expand
                                                           "degree_raise"
                                                           +)
                                                          (("1"
                                                            (lift-if)
                                                            (("1"
                                                              (ground)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (replace -1)
                                (("2"
                                  (hide -1)
                                  (("2"
                                    (hide -3)
                                    (("2"
                                      (expand "+" +)
                                      (("2"
                                        (rewrite "sigma_sum" :dir rl)
                                        (("2"
                                          (lemma "sigma_split")
                                          (("2"
                                            (inst
                                             -
                                             "Aleft"
                                             "mm+1"
                                             "0"
                                             "mm")
                                            (("1"
                                              (assert)
                                              (("1"
                                                (replace -1)
                                                (("1"
                                                  (hide -1)
                                                  (("1"
                                                    (case
                                                     "NOT sigma(1+mm,1+mm,Aleft) = 0")
                                                    (("1"
                                                      (hide 2)
                                                      (("1"
                                                        (expand
                                                         "sigma"
                                                         +)
                                                        (("1"
                                                          (expand
                                                           "sigma"
                                                           +)
                                                          (("1"
                                                            (expand
                                                             "Aleft"
                                                             +)
                                                            (("1"
                                                              (propax)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (replace -1)
                                                      (("2"
                                                        (hide -1)
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (lemma
                                                             "sigma_split")
                                                            (("2"
                                                              (inst
                                                               -
                                                               "Aright"
                                                               "mm+1"
                                                               "0"
                                                               "0")
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (replace
                                                                   -1)
                                                                  (("2"
                                                                    (hide
                                                                     -1)
                                                                    (("2"
                                                                      (case
                                                                       "NOT sigma(0,0,Aright) = 0")
                                                                      (("1"
                                                                        (hide
                                                                         2)
                                                                        (("1"
                                                                          (expand
                                                                           "sigma")
                                                                          (("1"
                                                                            (expand
                                                                             "sigma")
                                                                            (("1"
                                                                              (expand
                                                                               "Aright"
                                                                               +)
                                                                              (("1"
                                                                                (propax)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (replace
                                                                         -1)
                                                                        (("2"
                                                                          (hide
                                                                           -1)
                                                                          (("2"
                                                                            (assert)
                                                                            (("2"
                                                                              (lemma
                                                                               "sigma_shift_T2")
                                                                              (("2"
                                                                                (inst
                                                                                 -
                                                                                 "Aright"
                                                                                 "mm"
                                                                                 "0"
                                                                                 "1")
                                                                                (("2"
                                                                                  (assert)
                                                                                  (("2"
                                                                                    (replace
                                                                                     -1)
                                                                                    (("2"
                                                                                      (hide
                                                                                       -1)
                                                                                      (("2"
                                                                                        (name
                                                                                         "DD"
                                                                                         "LAMBDA (i: nat): Aright(1 + i)")
                                                                                        (("2"
                                                                                          (replace
                                                                                           -1)
                                                                                          (("2"
                                                                                            (case
                                                                                             "NOT AA = Aleft + DD")
                                                                                            (("1"
                                                                                              (hide
                                                                                               2)
                                                                                              (("1"
                                                                                                (decompose-equality)
                                                                                                (("1"
                                                                                                  (expand
                                                                                                   "+"
                                                                                                   +)
                                                                                                  (("1"
                                                                                                    (expand
                                                                                                     "AA"
                                                                                                     +)
                                                                                                    (("1"
                                                                                                      (expand
                                                                                                       "Aleft"
                                                                                                       +)
                                                                                                      (("1"
                                                                                                        (expand
                                                                                                         "DD"
                                                                                                         +)
                                                                                                        (("1"
                                                                                                          (lift-if)
                                                                                                          (("1"
                                                                                                            (assert)
                                                                                                            (("1"
                                                                                                              (ground)
                                                                                                              (("1"
                                                                                                                (expand
                                                                                                                 "Aright"
                                                                                                                 +)
                                                                                                                (("1"
                                                                                                                  (propax)
                                                                                                                  nil
                                                                                                                  nil))
                                                                                                                nil)
                                                                                                               ("2"
                                                                                                                (expand
                                                                                                                 "Aright"
                                                                                                                 +)
                                                                                                                (("2"
                                                                                                                  (lemma
                                                                                                                   "Bernstein_degree_raise")
                                                                                                                  (("2"
                                                                                                                    (inst
                                                                                                                     -
                                                                                                                     "1+mm"
                                                                                                                     "x!2"
                                                                                                                     "x!1")
                                                                                                                    (("2"
                                                                                                                      (assert)
                                                                                                                      nil
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil)
                                                                                             ("2"
                                                                                              (replace
                                                                                               -1)
                                                                                              (("2"
                                                                                                (hide
                                                                                                 -1)
                                                                                                (("2"
                                                                                                  (lemma
                                                                                                   "sigma_sum")
                                                                                                  (("2"
                                                                                                    (inst
                                                                                                     -
                                                                                                     "Aleft"
                                                                                                     "DD"
                                                                                                     "mm"
                                                                                                     "0")
                                                                                                    (("2"
                                                                                                      (expand
                                                                                                       "+"
                                                                                                       1
                                                                                                       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)
                                             ("2"
                                              (skosimp*)
                                              (("2" (assertnil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (skosimp*) (("2" (assertnil nil))
                              nil)
                             ("3" (skosimp*) (("3" (assertnil nil))
                              nil))
                            nil)
                           ("2" (skosimp*) (("2" (assertnil nil))
                            nil))
                          nil))
                        nil)
                       ("2" (skosimp*) (("2" (assertnil nil)) nil)
                       ("3" (skosimp*) (("3" (assertnil nil)) nil))
                      nil))
                    nil)
                   ("2" (skosimp*) (("2" (assertnil nil)) nil)
                   ("3" (skosimp*) (("3" (assertnil nil)) nil))
                  nil))
                nil)
               ("2" (hide 2)
                (("2" (expand "degree_raise") (("2" (propax) nil nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nat nonempty-type-eq-decl nil naturalnumbers nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (Bernstein_Polynomial type-eq-decl nil bernstein_polynomials nil)
    (Bern_poly const-decl "[real -> real]" bernstein_polynomials nil)
    (degree_raise const-decl "Bernstein_Polynomial"
     bernstein_polynomials 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)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (Bern const-decl "real" bernstein_polynomials nil)
    (above nonempty-type-eq-decl nil integers nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (> const-decl "bool" reals nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (<= const-decl "bool" reals nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (/= const-decl "boolean" notequal nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (+ const-decl "[T -> real]" real_fun_ops nil)
    (Aleft skolem-const-decl "[nat -> real]" bernstein_polynomials nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_div_nzreal_is_real application-judgement "real" reals nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (nnrat_div_posrat_is_nnrat application-judgement "nonneg_rat"
     rationals nil)
    (rat_div_nzrat_is_rat application-judgement "rat" rationals nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (Aright skolem-const-decl "[nat -> real]" bernstein_polynomials
     nil)
    (BB skolem-const-decl "[nat -> real]" bernstein_polynomials nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (sigma_split formula-decl nil sigma nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (sigma_shift_T2 formula-decl nil sigma nil)
    (even_plus_odd_is_odd application-judgement "odd_int" integers nil)
    (Bernstein_degree_raise formula-decl nil bernstein_polynomials nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (posrat_div_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (DD skolem-const-decl "[nat -> real]" bernstein_polynomials nil)
    (AA skolem-const-decl "[nat -> real]" bernstein_polynomials nil)
    (sigma def-decl "real" sigma nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (sigma_sum formula-decl nil sigma nil)
    (T_high type-eq-decl nil sigma nil)
    (T_low type-eq-decl nil sigma nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (int_minus_int_is_int application-judgement "int" integers nil))
   shostak))
 (degree_raise_power_id 0
  (degree_raise_power_id-1 nil 3480666697
   ("" (skeep)
    ((""
      (case "FORALL (jj:nat): Bern_poly(b) = Bern_poly(degree_raise_power(b, jj))")
      (("1" (inst - "j"nil nil)
       ("2" (hide 2)
        (("2" (induct "jj")
          (("1" (expand "degree_raise_power") (("1" (propax) nil nil))
            nil)
           ("2" (skosimp*)
            (("2" (expand "degree_raise_power" +)
              (("2" (lemma "degree_raise_id")
                (("2" (inst - "degree_raise_power(b,j!1)")
                  (("2" (assertnil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((degree_raise_power def-decl "Bernstein_Polynomial"
     bernstein_polynomials nil)
    (Bern_poly const-decl "[real -> real]" bernstein_polynomials nil)
    (Bernstein_Polynomial type-eq-decl nil bernstein_polynomials nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities 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)
    (pred type-eq-decl nil defined_types nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (degree_raise_id formula-decl nil bernstein_polynomials nil))
   nil))
 (Bern_poly_reverse_TCC1 0
  (Bern_poly_reverse_TCC1-1 nil 3485881402 ("" (subtype-tcc) nil nil)
   nil nil))
 (Bern_poly_reverse_sym_half 0
  (Bern_poly_reverse_sym_half-1 nil 3485881746
   ("" (skeep)
    (("" (expand "Bern_poly")
      (("" (case "Bern_poly_reverse(b)`index = b`index")
        (("1" (replace -1)
          (("1" (lemma "sigma_reverse")
            (("1" (inst?)
              (("1" (replace -1)
                (("1" (hide -1)
                  (("1" (assert)
                    (("1" (lemma "sigma_restrict_eq")
                      (("1" (inst?)
                        (("1" (assert)
                          (("1" (hide 2)
                            (("1" (decompose-equality 1)
                              (("1"
                                (expand "restrict")
                                (("1"
                                  (lift-if)
                                  (("1"
                                    (ground)
                                    (("1"
                                      (hide -)
                                      (("1"
                                        (expand "Bern_poly_reverse")
                                        (("1"
                                          (case
                                           "Bern(b`index - x!1, b`index)(1 / 2 + x) =
                      Bern(x!1, b`index)(1 / 2 - x)")
                                          (("1" (assertnil nil)
                                           ("2"
                                            (hide 3)
                                            (("2"
                                              (expand "Bern")
                                              (("2"
                                                (lemma "C_symmetry")
                                                (("2"
                                                  (inst
                                                   -
                                                   "b`index"
                                                   "x!1")
                                                  (("2"
                                                    (replace
                                                     -1
                                                     :dir
                                                     rl)
                                                    (("2"
                                                      (hide -1)
                                                      (("2"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (skosimp*)
                                (("2" (assertnil nil))
                                nil)
                               ("3"
                                (skosimp*)
                                (("3" (assertnil nil))
                                nil)
                               ("4"
                                (skosimp*)
                                (("4" (assertnil nil))
                                nil)
                               ("5"
                                (skosimp*)
                                (("5" (assertnil nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (skosimp*) (("2" (assertnil nil)) nil)
                         ("3" (skosimp*) (("3" (assertnil nil)) nil)
                         ("4" (skosimp*) (("4" (assertnil nil)) nil)
                         ("5" (skosimp*) (("5" (assertnil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (skosimp*) (("2" (assertnil nil)) nil)
               ("3" (skosimp*) (("3" (assertnil nil)) nil))
              nil))
            nil))
          nil)
         ("2" (hide 2)
          (("2" (expand "Bern_poly_reverse") (("2" (propax) nil nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((Bern_poly const-decl "[real -> real]" bernstein_polynomials nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (<= const-decl "bool" reals nil)
    (b skolem-const-decl "Bernstein_Polynomial" bernstein_polynomials
     nil)
    (> const-decl "bool" reals nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans 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_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (above nonempty-type-eq-decl nil integers nil)
    (Bern const-decl "real" bernstein_polynomials nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (sigma_restrict_eq formula-decl nil sigma nil)
    (restrict const-decl "[T -> real]" sigma nil)
    (/= const-decl "boolean" notequal nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (posrat_div_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (C_symmetry formula-decl nil binomial nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (T_high type-eq-decl nil sigma nil)
    (T_low type-eq-decl nil sigma nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_minus_real_is_real application-judgement "real" reals 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)
    (sigma_reverse formula-decl nil sigma_nat nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (real nonempty-type-from-decl nil reals nil)
    (Bernstein_Polynomial type-eq-decl nil bernstein_polynomials nil)
    (Bern_poly_reverse const-decl "Bernstein_Polynomial"
     bernstein_polynomials nil))
   nil))
 (Bern_poly_reverse_sym 0
  (Bern_poly_reverse_sym-1 nil 3485881402
   ("" (skeep)
    (("" (lemma "Bern_poly_reverse_sym_half")
      (("" (inst - "b" "x-1/2") (("" (assertnil nil)) nil)) nil))
    nil)
   ((Bern_poly_reverse_sym_half formula-decl nil bernstein_polynomials
     nil)
    (posrat_div_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/= const-decl "boolean" notequal nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields 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)
    (Bernstein_Polynomial type-eq-decl nil bernstein_polynomials nil)
    (real nonempty-type-from-decl nil reals nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (real_minus_real_is_real application-judgement "real" reals nil))
   shostak))
 (Bern_poly_inverse_TCC1 0
  (Bern_poly_inverse_TCC1-1 nil 3479635199 ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (>= const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (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))
   nil))
 (Bern_poly_inverse_TCC2 0
  (Bern_poly_inverse_TCC2-1 nil 3479644701 ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (>= const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (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))
   nil))
 (Bern_poly_inverse_TCC3 0
  (Bern_poly_inverse_TCC3-1 nil 3479644701 ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (>= const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (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))
   nil))
 (Bern_structural_decomp_TCC1 0
  (Bern_structural_decomp_TCC1-1 nil 3480943595
   ("" (subtype-tcc) nil nil)
   ((Bernstein_Polynomial type-eq-decl nil bernstein_polynomials nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (<= const-decl "bool" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil))
   nil))
 (Bern_structural_decomp 0
  (Bern_structural_decomp-1 nil 3480943595
   ("" (skeep)
    ((""
      (case "FORALL (mm: nat): (FORALL (bb:Bernstein_Polynomial): ((bb`index >= mm AND (FORALL (j:upto(bb`index)): j>mm IMPLIES bb`bern_seq(j) = 0)) IMPLIES P(bb)))")
      (("1" (skeep)
        (("1" (inst - "b`index")
          (("1" (inst - "b") (("1" (assertnil nil)) nil)) nil))
        nil)
       ("2" (hide 2)
        (("2" (induct "mm")
          (("1" (skeep)
            (("1" (inst -4 "0" "bb`index" "bb`bern_seq(0)")
              (("1" (assert)
                (("1"
                  (case "bb = (# index := bb`index,
                        bern_seq
                          := LAMBDA (j: upto(bb`index)):
                               IF j = 0 THEN bb`bern_seq(0) ELSE 0 ENDIF #)")
                  (("1" (assertnil nil)
                   ("2" (hide 2)
                    (("2" (decompose-equality)
                      (("2" (decompose-equality)
                        (("2" (lift-if)
                          (("2" (ground)
                            (("2" (inst - "x!1")
                              (("2" (assertnil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (assertnil nil))
              nil))
            nil)
           ("2" (skosimp*)
            (("2"
              (name "bb1"
                    "(# index := bb!1`index, bern_seq := (LAMBDA (i:upto(bb!1`index)): IF i <= j!1 THEN bb!1`bern_seq(i) ELSE 0 ENDIF) #)")
              (("2"
                (name "bb2"
                      "(# index := bb!1`index, bern_seq := (LAMBDA (i:upto(bb!1`index)): IF i = 1+j!1 THEN bb!1`bern_seq(1+j!1) ELSE 0 ENDIF) #)")
                (("1" (inst - "bb1")
                  (("1" (assert)
                    (("1" (split -3)
                      (("1" (inst -6 "bb1" "bb2")
                        (("1"
                          (inst -7 "1+j!1" "bb!1`index"
                           "bb!1`bern_seq(1+j!1)")
                          (("1" (assert)
                            (("1" (replace -2)
                              (("1"
                                (assert)
                                (("1"
                                  (case
                                   "bb!1 = (# index := bb1`index,
                                bern_seq
                                  := LAMBDA (i: upto(bb1`index)):
                                       bb1`bern_seq(i) + bb2`bern_seq(i) #)")
                                  (("1" (assertnil nil)
                                   ("2"
                                    (hide 2)
                                    (("2"
                                      (decompose-equality)
                                      (("2"
                                        (decompose-equality)
                                        (("1"
                                          (expand "bb1" +)
                                          (("1"
                                            (expand "bb2" +)
                                            (("1"
                                              (lift-if)
                                              (("1"
                                                (lift-if)
                                                (("1"
                                                  (ground)
                                                  (("1"
                                                    (typepred "x!1")
                                                    (("1"
                                                      (inst - "x!1")
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (lift-if)
                                                          (("1"
                                                            (ground)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (skeep)
                                          (("2" (ground) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (skeep) (("2" (ground) nil nil)) nil))
                        nil)
                       ("2" (skeep)
                        (("2" (expand "bb1" 1)
                          (("2" (lift-if) (("2" (ground) nil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (skeep) (("2" (ground) nil nil)) nil))
                  nil)
                 ("2" (skeep) (("2" (ground) nil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((= const-decl "[T, T -> boolean]" equalities nil)
    (> const-decl "bool" reals nil) (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (Bernstein_Polynomial type-eq-decl nil bernstein_polynomials nil)
    (upto nonempty-type-eq-decl nil naturalnumbers 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)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (pred type-eq-decl nil defined_types nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (bb skolem-const-decl "Bernstein_Polynomial" bernstein_polynomials
     nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (IFF const-decl "[bool, bool -> bool]" booleans nil)
    (bb!1 skolem-const-decl "Bernstein_Polynomial"
     bernstein_polynomials nil)
    (bb1 skolem-const-decl
     "[# bern_seq: [upto(bb!1`index) -> real], index: nat #]"
     bernstein_polynomials nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bb2 skolem-const-decl
     "[# bern_seq: [upto(bb!1`index) -> real], index: nat #]"
     bernstein_polynomials nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil))
   shostak))
 (Bernstein_polynomial_TCC1 0
  (Bernstein_polynomial_TCC1-1 nil 3479481006
   ("" (subtype-tcc) nil nilnil nil))
 (Bernstein_polynomial_TCC2 0
  (Bernstein_polynomial_TCC2-1 nil 3479481006
   ("" (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)
    (upto nonempty-type-eq-decl nil naturalnumbers 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_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (Bernstein_polynomial_TCC3 0
  (Bernstein_polynomial_TCC3-1 nil 3479486699
   ("" (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)
    (upto nonempty-type-eq-decl nil naturalnumbers 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_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (Bernstein_equivalence 0
  (Bernstein_equivalence-1 nil 3479481006
   ("" (skeep)
    ((""
      (case "FORALL (pp: nat): m>=pp IMPLIES polynomial(a, pp) = Bern_poly(Bernstein_polynomial(a, pp, m))")
      (("1" (inst - "p") (("1" (assertnil nil)) nil)
       ("2" (hide 2)
        (("2" (lemma "NAT_induction")
          (("2" (inst?)
            (("2" (skeep)
              (("2" (split -)
                (("1" (inst - "pp") (("1" (assertnil nil)) nil)
                 ("2" (hide 2)
                  (("2" (skeep)
                    (("2" (case "j = 0")
                      (("1" (replace -1)
                        (("1" (hide -1)
                          (("1" (hide -1)
                            (("1" (decompose-equality)
                              (("1"
                                (expand "polynomial")
                                (("1"
                                  (expand "sigma")
                                  (("1"
                                    (assert)
                                    (("1"
                                      (expand "Bern_poly")
                                      (("1"
                                        (expand "Bernstein_polynomial")
                                        (("1"
                                          (name
                                           "AA"
                                           "LAMBDA (i: nat):
                                                                                                            IF i > m THEN 0
                                                                                                            ELSE sigma(0, i,
                                                                                                                       LAMBDA (i_1: nat):
                                                                                                                         IF i_1 > i OR i_1 > 0 THEN 0
                                                                                                                         ELSE a(i_1) * (C(i, i_1) / C(m, i_1))
                                                                                                                         ENDIF)
                                                                                                                  * Bern(i, m)(x!1)
                                                                                                            ENDIF")
                                          (("1"
                                            (replace -1)
                                            (("1"
                                              (case
                                               "AA = LAMBDA (i: nat): IF i>m THEN 0 ELSE a(0)*Bern(i,m)(x!1) ENDIF")
                                              (("1"
                                                (replace -1)
                                                (("1"
                                                  (lemma "sigma_scal")
                                                  (("1"
                                                    (name
                                                     "BB"
                                                     "LAMBDA (i: nat):
                                                                                                                                   IF i > m THEN 0 ELSE Bern(i, m)(x!1) ENDIF")
                                                    (("1"
                                                      (inst
                                                       -
                                                       "BB"
                                                       "a(0)"
                                                       "m"
                                                       "0")
                                                      (("1"
                                                        (case
                                                         "(LAMBDA (i: nat): a(0) * BB(i)) = AA")
                                                        (("1"
                                                          (replace -1)
                                                          (("1"
                                                            (replace
                                                             -4
                                                             :dir
                                                             rl)
                                                            (("1"
                                                              (replace
                                                               -3)
                                                              (("1"
                                                                (case
                                                                 "sigma(0,m,BB) = 1")
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil)
                                                                 ("2"
                                                                  (hide
                                                                   2)
                                                                  (("2"
                                                                    (hide
                                                                     (-3
                                                                      -4
                                                                      -5))
                                                                    (("2"
                                                                      (lemma
                                                                       "Bernstein_partition_of_unity")
                                                                      (("2"
                                                                        (inst
                                                                         -
                                                                         "m"
                                                                         "x!1")
                                                                        (("2"
                                                                          (assert)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (hide 2)
                                                          (("2"
                                                            (replace
                                                             -3)
                                                            (("2"
                                                              (decompose-equality)
                                                              (("1"
                                                                (replace
                                                                 -1
                                                                 :dir
                                                                 rl)
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (lift-if)
                                                                    (("1"
                                                                      (ground)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (skeep)
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (replace -1 1 :dir rl)
                                                (("2"
                                                  (decompose-equality)
                                                  (("1"
                                                    (lift-if)
                                                    (("1"
                                                      (ground)
                                                      (("1"
                                                        (lemma
                                                         "sigma_split")
                                                        (("1"
                                                          (inst
                                                           -
                                                           "LAMBDA (i_1: nat):
                                                                  IF i_1 > x!2 OR i_1 > 0 THEN 0
                                                                  ELSE a(i_1) * (C(x!2, i_1) / C(m, i_1))
                                                                  ENDIF"
                                                           "x!2"
                                                           "0"
                                                           "0")
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (replace
                                                               -1)
                                                              (("1"
                                                                (hide
                                                                 -1)
                                                                (("1"
                                                                  (expand
                                                                   "sigma"
                                                                   2
                                                                   1)
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (lemma
                                                                       "sigma_restrict_eq")
                                                                      (("1"
                                                                        (inst
                                                                         -
                                                                         "LAMBDA (i_1: nat):
                                                                           IF i_1 > x!2 OR i_1 > 0 THEN 0
                                                                           ELSE a(i_1) * (C(x!2, i_1) / C(m, i_1))
                                                                           ENDIF"
                                                                         "LAMBDA (i_1: nat):
                                                                           0"
                                                                         "x!2"
                                                                         "1")
                                                                        (("1"
                                                                          (split
                                                                           -)
                                                                          (("1"
                                                                            (lemma
                                                                             "sigma_zero")
                                                                            (("1"
                                                                              (inst
                                                                               -
                                                                               "x!2"
                                                                               "1")
                                                                              (("1"
                                                                                (replace
                                                                                 -1)
                                                                                (("1"
                                                                                  (mult-by
                                                                                   -2
                                                                                   "Bern(x!2, m)(x!1)")
                                                                                  (("1"
                                                                                    (replace
                                                                                     -1)
                                                                                    (("1"
                                                                                      (expand
                                                                                       "C")
                                                                                      (("1"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil)
                                                                                   ("2"
                                                                                    (skeep)
                                                                                    (("2"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil)
                                                                                   ("3"
                                                                                    (skeep)
                                                                                    (("3"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (decompose-equality)
                                                                            (("1"
                                                                              (expand
                                                                               "restrict")
                                                                              (("1"
                                                                                (propax)
                                                                                nil
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (skeep)
                                                                              (("2"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil)
                                                                             ("3"
                                                                              (skeep)
                                                                              (("3"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (skeep)
                                                                          (("2"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil)
                                                                         ("3"
                                                                          (skeep)
                                                                          (("3"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (skeep)
                                                            (("2"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil)
                                                           ("3"
                                                            (skeep)
                                                            (("3"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (skeep)
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil)
                                                   ("3"
                                                    (skosimp*)
                                                    (("3"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil)
                                                   ("4"
                                                    (skosimp*)
                                                    (("4"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (skosimp*)
                                            (("2" (assertnil nil))
                                            nil)
                                           ("3"
                                            (skosimp*)
                                            (("3" (assertnil nil))
                                            nil)
                                           ("4"
                                            (skosimp*)
                                            (("4" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (inst - "j-1")
                        (("1" (assert)
                          (("1"
                            (name "aa"
                                  "LAMBDA (kz:nat): IF kz/=j THEN 0 ELSE a(j) ENDIF")
                            (("1"
                              (case "polynomial(a,j) = polynomial(a,j-1) + polynomial(aa,j)")
                              (("1"
                                (case
                                 "Bern_poly(Bernstein_polynomial(a, j, m))=Bern_poly(Bernstein_polynomial(a, j-1, m))+Bern_poly(Bernstein_polynomial(aa, j, m))")
                                (("1"
                                  (case
                                   "polynomial(aa,j) = Bern_poly(Bernstein_polynomial(aa,j,m))")
                                  (("1" (assertnil nil)
                                   ("2"
                                    (hide 3)
                                    (("2"
                                      (hide -1)
                                      (("2"
                                        (hide -1)
                                        (("2"
                                          (hide -2)
                                          (("2"
                                            (decompose-equality)
                                            (("2"
                                              (expand "polynomial")
                                              (("2"
                                                (expand
                                                 "Bernstein_polynomial")
                                                (("2"
                                                  (expand "Bern_poly")
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (lemma
                                                       "sigma_split")
                                                      (("2"
                                                        (inst
                                                         -
                                                         "LAMBDA (i: nat): aa(i) * (IF i = 0 THEN 1 ELSE x!1 ^ i ENDIF)"
                                                         "j"
                                                         "0"
                                                         "j-1")
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (replace
                                                             -1)
                                                            (("2"
                                                              (hide -1)
                                                              (("2"
                                                                (lemma
                                                                 "sigma_restrict_eq")
                                                                (("2"
                                                                  (inst
                                                                   -
                                                                   "LAMBDA (i: nat): aa(i) * (IF i = 0 THEN 1 ELSE x!1 ^ i ENDIF)"
                                                                   "LAMBDA (i: nat): 0"
                                                                   "j-1"
                                                                   "0")
                                                                  (("2"
                                                                    (split
                                                                     -1)
                                                                    (("1"
                                                                      (lemma
                                                                       "sigma_zero")
                                                                      (("1"
                                                                        (inst?)
                                                                        (("1"
                                                                          (replace
                                                                           -1)
                                                                          (("1"
                                                                            (hide
                                                                             -1)
                                                                            (("1"
                                                                              (replace
                                                                               -1)
                                                                              (("1"
                                                                                (hide
                                                                                 -1)
                                                                                (("1"
                                                                                  (assert)
                                                                                  (("1"
                                                                                    (expand
                                                                                     "sigma"
                                                                                     1
                                                                                     1)
                                                                                    (("1"
                                                                                      (assert)
                                                                                      (("1"
                                                                                        (expand
                                                                                         "sigma"
                                                                                         1
                                                                                         1)
                                                                                        (("1"
                                                                                          (case
                                                                                           "aa(j) = a(j)")
                                                                                          (("1"
                                                                                            (replace
                                                                                             -1)
                                                                                            (("1"
                                                                                              (hide
                                                                                               -1)
                                                                                              (("1"
                                                                                                (lemma
                                                                                                 "Bernstein_conversion_2")
                                                                                                (("1"
                                                                                                  (inst
                                                                                                   -
                                                                                                   "m"
                                                                                                   "j"
                                                                                                   "x!1")
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    (("1"
                                                                                                      (mult-by
                                                                                                       -1
                                                                                                       "a(j)")
                                                                                                      (("1"
                                                                                                        (lemma
                                                                                                         "sigma_scal")
                                                                                                        (("1"
                                                                                                          (inst?)
                                                                                                          (("1"
                                                                                                            (inst
                                                                                                             -
                                                                                                             "a(j)")
                                                                                                            (("1"
                                                                                                              (replace
                                                                                                               -1
                                                                                                               :dir
                                                                                                               rl)
                                                                                                              (("1"
                                                                                                                (hide
                                                                                                                 -1)
                                                                                                                (("1"
                                                                                                                  (lemma
                                                                                                                   "sigma_restrict_eq")
                                                                                                                  (("1"
                                                                                                                    (inst
                                                                                                                     -
                                                                                                                     "LAMBDA (i_1: nat):
                                       a(j) *
                                        IF i_1 < j OR i_1 > m THEN 0
                                        ELSE (C(i_1, j) / C(m, j)) * Bern(i_1, m)(x!1)
                                        ENDIF"
                                                                                                                     "LAMBDA (i_1: nat):
                                       IF i_1 > m THEN 0
                                       ELSE sigma(0, i_1,
                                                  LAMBDA (i: nat):
                                                    IF i > i_1 OR i > j THEN 0
                                                    ELSE aa(i) * (C(i_1, i) / C(m, i))
                                                    ENDIF)
                                             * Bern(i_1, m)(x!1)
                                       ENDIF"
                                                                                                                     "m"
                                                                                                                     "0")
                                                                                                                    (("1"
                                                                                                                      (assert)
                                                                                                                      (("1"
                                                                                                                        (hide
                                                                                                                         2)
                                                                                                                        (("1"
                                                                                                                          (hide
                                                                                                                           -1)
                                                                                                                          (("1"
                                                                                                                            (decompose-equality)
                                                                                                                            (("1"
                                                                                                                              (expand
                                                                                                                               "restrict")
                                                                                                                              (("1"
                                                                                                                                (lift-if)
                                                                                                                                (("1"
                                                                                                                                  (ground)
                                                                                                                                  (("1"
                                                                                                                                    (lemma
                                                                                                                                     "sigma_restrict_eq")
                                                                                                                                    (("1"
                                                                                                                                      (inst
                                                                                                                                       -
                                                                                                                                       "LAMBDA (i: nat):
                                             IF i > x!2 OR i > j THEN 0
                                             ELSE aa(i) * (C(x!2, i) / C(m, i))
                                             ENDIF"
                                                                                                                                       "LAMBDA (i: nat): 0"
                                                                                                                                       "x!2"
                                                                                                                                       "0")
                                                                                                                                      (("1"
                                                                                                                                        (split
                                                                                                                                         -1)
                                                                                                                                        (("1"
                                                                                                                                          (lemma
                                                                                                                                           "sigma_zero")
                                                                                                                                          (("1"
                                                                                                                                            (inst
                                                                                                                                             -
                                                                                                                                             "x!2"
                                                                                                                                             "0")
                                                                                                                                            (("1"
                                                                                                                                              (assert)
                                                                                                                                              nil
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil)
                                                                                                                                         ("2"
                                                                                                                                          (hide
                                                                                                                                           2)
                                                                                                                                          (("2"
                                                                                                                                            (expand
                                                                                                                                             "restrict")
                                                                                                                                            (("2"
                                                                                                                                              (decompose-equality)
                                                                                                                                              (("1"
                                                                                                                                                (lift-if)
                                                                                                                                                (("1"
                                                                                                                                                  (ground)
                                                                                                                                                  (("1"
                                                                                                                                                    (replace
                                                                                                                                                     -2
                                                                                                                                                     :dir
                                                                                                                                                     rl)
                                                                                                                                                    (("1"
                                                                                                                                                      (assert)
                                                                                                                                                      nil
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil)
                                                                                                                                               ("2"
                                                                                                                                                (skeep)
                                                                                                                                                (("2"
                                                                                                                                                  (assert)
                                                                                                                                                  nil
                                                                                                                                                  nil))
                                                                                                                                                nil)
                                                                                                                                               ("3"
                                                                                                                                                (skeep)
                                                                                                                                                (("3"
                                                                                                                                                  (assert)
                                                                                                                                                  nil
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil)
                                                                                                                                       ("2"
                                                                                                                                        (skeep)
                                                                                                                                        (("2"
                                                                                                                                          (assert)
                                                                                                                                          nil
                                                                                                                                          nil))
                                                                                                                                        nil)
                                                                                                                                       ("3"
                                                                                                                                        (skeep)
                                                                                                                                        (("3"
                                                                                                                                          (assert)
                                                                                                                                          nil
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil)
                                                                                                                                   ("2"
                                                                                                                                    (name
                                                                                                                                     "BB"
                                                                                                                                     "LAMBDA (i: nat):
                                                  IF i > x!2 OR i > j THEN 0
                                                  ELSE aa(i) * (C(x!2, i) / C(m, i))
                                                  ENDIF")
                                                                                                                                    (("1"
                                                                                                                                      (replace
                                                                                                                                       -1)
                                                                                                                                      (("1"
                                                                                                                                        (lemma
                                                                                                                                         "sigma_split")
                                                                                                                                        (("1"
                                                                                                                                          (inst
                                                                                                                                           -
                                                                                                                                           "BB"
                                                                                                                                           "x!2"
                                                                                                                                           "0"
                                                                                                                                           "j-1")
                                                                                                                                          (("1"
                                                                                                                                            (assert)
                                                                                                                                            (("1"
                                                                                                                                              (replace
                                                                                                                                               -1)
                                                                                                                                              (("1"
                                                                                                                                                (hide
                                                                                                                                                 -1)
                                                                                                                                                (("1"
                                                                                                                                                  (case
                                                                                                                                                   "sigma(0,j-1,BB) = 0")
                                                                                                                                                  (("1"
                                                                                                                                                    (replace
                                                                                                                                                     -1)
                                                                                                                                                    (("1"
                                                                                                                                                      (hide
                                                                                                                                                       -1)
                                                                                                                                                      (("1"
                                                                                                                                                        (assert)
                                                                                                                                                        (("1"
                                                                                                                                                          (case
                                                                                                                                                           "x!2 = j")
                                                                                                                                                          (("1"
                                                                                                                                                            (replace
                                                                                                                                                             -1)
                                                                                                                                                            (("1"
                                                                                                                                                              (expand
                                                                                                                                                               "sigma"
                                                                                                                                                               +)
                                                                                                                                                              (("1"
                                                                                                                                                                (expand
                                                                                                                                                                 "sigma"
                                                                                                                                                                 +)
                                                                                                                                                                (("1"
                                                                                                                                                                  (replace
                                                                                                                                                                   -2
                                                                                                                                                                   :dir
                                                                                                                                                                   rl)
                                                                                                                                                                  (("1"
                                                                                                                                                                    (assert)
                                                                                                                                                                    (("1"
                                                                                                                                                                      (replace
                                                                                                                                                                       -3
                                                                                                                                                                       +
                                                                                                                                                                       :dir
                                                                                                                                                                       rl)
                                                                                                                                                                      (("1"
                                                                                                                                                                        (assert)
                                                                                                                                                                        nil
                                                                                                                                                                        nil))
                                                                                                                                                                      nil))
                                                                                                                                                                    nil))
                                                                                                                                                                  nil))
                                                                                                                                                                nil))
                                                                                                                                                              nil))
                                                                                                                                                            nil)
                                                                                                                                                           ("2"
                                                                                                                                                            (lemma
                                                                                                                                                             "sigma_split")
                                                                                                                                                            (("2"
                                                                                                                                                              (inst
                                                                                                                                                               -
                                                                                                                                                               "BB"
                                                                                                                                                               "x!2"
                                                                                                                                                               "j"
                                                                                                                                                               "j")
                                                                                                                                                              (("2"
                                                                                                                                                                (assert)
                                                                                                                                                                (("2"
                                                                                                                                                                  (case
                                                                                                                                                                   "sigma(1+j,x!2,BB) = 0")
                                                                                                                                                                  (("1"
                                                                                                                                                                    (replace
                                                                                                                                                                     -1)
                                                                                                                                                                    (("1"
                                                                                                                                                                      (assert)
                                                                                                                                                                      (("1"
                                                                                                                                                                        (replace
                                                                                                                                                                         -2)
                                                                                                                                                                        (("1"
                                                                                                                                                                          (expand
                                                                                                                                                                           "sigma"
                                                                                                                                                                           +)
                                                                                                                                                                          (("1"
                                                                                                                                                                            (expand
                                                                                                                                                                             "sigma"
                                                                                                                                                                             +)
                                                                                                                                                                            (("1"
                                                                                                                                                                              (replace
                                                                                                                                                                               -3
                                                                                                                                                                               +
                                                                                                                                                                               :dir
                                                                                                                                                                               rl)
                                                                                                                                                                              (("1"
                                                                                                                                                                                (assert)
                                                                                                                                                                                (("1"
                                                                                                                                                                                  (replace
                                                                                                                                                                                   -4
                                                                                                                                                                                   +
                                                                                                                                                                                   :dir
                                                                                                                                                                                   rl)
                                                                                                                                                                                  (("1"
                                                                                                                                                                                    (assert)
                                                                                                                                                                                    nil
                                                                                                                                                                                    nil))
                                                                                                                                                                                  nil))
                                                                                                                                                                                nil))
                                                                                                                                                                              nil))
                                                                                                                                                                            nil))
                                                                                                                                                                          nil))
                                                                                                                                                                        nil))
                                                                                                                                                                      nil))
                                                                                                                                                                    nil)
                                                                                                                                                                   ("2"
                                                                                                                                                                    (lemma
                                                                                                                                                                     "sigma_restrict_eq")
                                                                                                                                                                    (("2"
                                                                                                                                                                      (inst
                                                                                                                                                                       -
                                                                                                                                                                       "BB"
                                                                                                                                                                       "LAMBDA (i:nat): 0"
                                                                                                                                                                       "x!2"
                                                                                                                                                                       "1+j")
                                                                                                                                                                      (("2"
                                                                                                                                                                        (split
                                                                                                                                                                         -1)
                                                                                                                                                                        (("1"
                                                                                                                                                                          (lemma
                                                                                                                                                                           "sigma_zero")
                                                                                                                                                                          (("1"
                                                                                                                                                                            (inst
                                                                                                                                                                             -
                                                                                                                                                                             "x!2"
                                                                                                                                                                             "1+j")
                                                                                                                                                                            (("1"
                                                                                                                                                                              (assert)
                                                                                                                                                                              nil
                                                                                                                                                                              nil))
                                                                                                                                                                            nil))
                                                                                                                                                                          nil)
                                                                                                                                                                         ("2"
                                                                                                                                                                          (decompose-equality)
                                                                                                                                                                          (("2"
                                                                                                                                                                            (expand
                                                                                                                                                                             "restrict")
                                                                                                                                                                            (("2"
                                                                                                                                                                              (lift-if)
                                                                                                                                                                              (("2"
                                                                                                                                                                                (ground)
                                                                                                                                                                                (("2"
                                                                                                                                                                                  (replace
                                                                                                                                                                                   -2
                                                                                                                                                                                   +
                                                                                                                                                                                   :dir
                                                                                                                                                                                   rl)
                                                                                                                                                                                  (("2"
                                                                                                                                                                                    (assert)
                                                                                                                                                                                    nil
                                                                                                                                                                                    nil))
                                                                                                                                                                                  nil))
                                                                                                                                                                                nil))
                                                                                                                                                                              nil))
                                                                                                                                                                            nil))
                                                                                                                                                                          nil))
                                                                                                                                                                        nil))
                                                                                                                                                                      nil))
                                                                                                                                                                    nil))
                                                                                                                                                                  nil))
                                                                                                                                                                nil))
                                                                                                                                                              nil))
                                                                                                                                                            nil))
                                                                                                                                                          nil))
                                                                                                                                                        nil))
                                                                                                                                                      nil))
                                                                                                                                                    nil)
                                                                                                                                                   ("2"
                                                                                                                                                    (lemma
                                                                                                                                                     "sigma_restrict_eq")
                                                                                                                                                    (("2"
                                                                                                                                                      (inst
                                                                                                                                                       -
                                                                                                                                                       "BB"
                                                                                                                                                       "LAMBDA (i:nat): 0"
                                                                                                                                                       "j-1"
                                                                                                                                                       "0")
                                                                                                                                                      (("2"
                                                                                                                                                        (split
                                                                                                                                                         -1)
                                                                                                                                                        (("1"
                                                                                                                                                          (lemma
                                                                                                                                                           "sigma_zero")
                                                                                                                                                          (("1"
                                                                                                                                                            (inst
                                                                                                                                                             -
                                                                                                                                                             "j-1"
                                                                                                                                                             "0")
                                                                                                                                                            (("1"
                                                                                                                                                              (assert)
                                                                                                                                                              nil
                                                                                                                                                              nil))
                                                                                                                                                            nil))
                                                                                                                                                          nil)
                                                                                                                                                         ("2"
                                                                                                                                                          (decompose-equality)
                                                                                                                                                          (("2"
                                                                                                                                                            (expand
                                                                                                                                                             "restrict")
                                                                                                                                                            (("2"
                                                                                                                                                              (lift-if)
                                                                                                                                                              (("2"
                                                                                                                                                                (ground)
                                                                                                                                                                (("2"
                                                                                                                                                                  (replace
                                                                                                                                                                   -1
                                                                                                                                                                   +
                                                                                                                                                                   :dir
                                                                                                                                                                   rl)
                                                                                                                                                                  (("2"
                                                                                                                                                                    (assert)
                                                                                                                                                                    (("2"
                                                                                                                                                                      (replace
                                                                                                                                                                       -2
                                                                                                                                                                       :dir
                                                                                                                                                                       rl)
                                                                                                                                                                      (("2"
                                                                                                                                                                        (assert)
                                                                                                                                                                        nil
                                                                                                                                                                        nil))
                                                                                                                                                                      nil))
                                                                                                                                                                    nil))
                                                                                                                                                                  nil))
                                                                                                                                                                nil))
                                                                                                                                                              nil))
                                                                                                                                                            nil))
                                                                                                                                                          nil))
                                                                                                                                                        nil))
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil)
                                                                                                                                     ("2"
                                                                                                                                      (skosimp*)
                                                                                                                                      (("2"
                                                                                                                                        (assert)
                                                                                                                                        nil
                                                                                                                                        nil))
                                                                                                                                      nil)
                                                                                                                                     ("3"
                                                                                                                                      (skosimp*)
                                                                                                                                      (("3"
                                                                                                                                        (assert)
                                                                                                                                        nil
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil)
                                                                                                                             ("2"
                                                                                                                              (skosimp*)
                                                                                                                              (("2"
                                                                                                                                (assert)
                                                                                                                                nil
                                                                                                                                nil))
                                                                                                                              nil)
                                                                                                                             ("3"
                                                                                                                              (skosimp*)
                                                                                                                              (("3"
                                                                                                                                (assert)
                                                                                                                                nil
                                                                                                                                nil))
                                                                                                                              nil)
                                                                                                                             ("4"
                                                                                                                              (skosimp*)
                                                                                                                              (("4"
                                                                                                                                (assert)
                                                                                                                                nil
                                                                                                                                nil))
                                                                                                                              nil)
                                                                                                                             ("5"
                                                                                                                              (skosimp*)
                                                                                                                              (("5"
                                                                                                                                (assert)
                                                                                                                                nil
                                                                                                                                nil))
                                                                                                                              nil)
                                                                                                                             ("6"
                                                                                                                              (skosimp*)
                                                                                                                              (("6"
                                                                                                                                (assert)
                                                                                                                                nil
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil)
                                                                                                                     ("2"
                                                                                                                      (skosimp*)
                                                                                                                      (("2"
                                                                                                                        (assert)
                                                                                                                        nil
                                                                                                                        nil))
                                                                                                                      nil)
                                                                                                                     ("3"
                                                                                                                      (skosimp*)
                                                                                                                      (("3"
                                                                                                                        (assert)
                                                                                                                        nil
                                                                                                                        nil))
                                                                                                                      nil)
                                                                                                                     ("4"
                                                                                                                      (skosimp*)
                                                                                                                      (("4"
                                                                                                                        (assert)
                                                                                                                        nil
                                                                                                                        nil))
                                                                                                                      nil)
                                                                                                                     ("5"
                                                                                                                      (skosimp*)
                                                                                                                      (("5"
                                                                                                                        (assert)
                                                                                                                        nil
                                                                                                                        nil))
                                                                                                                      nil)
                                                                                                                     ("6"
                                                                                                                      (skosimp*)
                                                                                                                      (("6"
                                                                                                                        (assert)
                                                                                                                        nil
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil)
                                                                                                           ("2"
                                                                                                            (skosimp*)
                                                                                                            (("2"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil)
                                                                                                           ("3"
                                                                                                            (skosimp*)
                                                                                                            (("3"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil)
                                                                                                       ("2"
                                                                                                        (skosimp*)
                                                                                                        (("2"
                                                                                                          (assert)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil)
                                                                                                       ("3"
                                                                                                        (skosimp*)
                                                                                                        (("3"
                                                                                                          (assert)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (replace
                                                                                             -1
                                                                                             :dir
                                                                                             rl)
                                                                                            (("2"
                                                                                              (assert)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (decompose-equality)
                                                                      (("2"
                                                                        (expand
                                                                         "restrict")
                                                                        (("2"
                                                                          (lift-if)
                                                                          (("2"
                                                                            (ground)
                                                                            (("1"
                                                                              (replace
                                                                               -2
                                                                               :dir
                                                                               rl)
                                                                              (("1"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (replace
                                                                               -1
                                                                               :dir
                                                                               rl)
                                                                              (("2"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (decompose-equality)
                                  (("2"
                                    (expand "+" 1)
                                    (("2"
                                      (expand "Bern_poly" 1)
                                      (("2"
                                        (expand
                                         "Bernstein_polynomial"
                                         1)
                                        (("2"
                                          (name
                                           "AA"
                                           "LAMBDA (i: nat):
                                 IF i > m THEN 0
                                 ELSE sigma(0, i,
                                            LAMBDA (i_1: nat):
                                              IF i_1 > i OR i_1 > j THEN 0
                                              ELSE a(i_1) * (C(i, i_1) / C(m, i_1))
                                              ENDIF)
                                       * Bern(i, m)(x!1)
                                 ENDIF")
                                          (("1"
                                            (replace -1)
                                            (("1"
                                              (name
                                               "BB"
                                               "LAMBDA (i: nat):
                                    IF i > m THEN 0
                                    ELSE sigma(0, i,
                                               LAMBDA (i_1: nat):
                                                 IF i_1 > i OR i_1 > j THEN 0
                                                 ELSE aa(i_1) * (C(i, i_1) / C(m, i_1))
                                                 ENDIF)
                                          * Bern(i, m)(x!1)
                                    ENDIF")
                                              (("1"
                                                (replace -1)
                                                (("1"
                                                  (name
                                                   "CC"
                                                   "LAMBDA (i: nat):
                                     IF i > m THEN 0
                                     ELSE sigma(0, i,
                                                LAMBDA (i_1: nat):
                                                  IF i_1 > i OR i_1 > j - 1 THEN 0
                                                  ELSE a(i_1) * (C(i, i_1) / C(m, i_1))
                                                  ENDIF)
                                           * Bern(i, m)(x!1)
                                     ENDIF")
                                                  (("1"
                                                    (replace -1)
                                                    (("1"
                                                      (case
                                                       "AA = (LAMBDA (i:nat): BB(i)+CC(i))")
                                                      (("1"
                                                        (lemma
                                                         "sigma_sum")
                                                        (("1"
                                                          (inst?)
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (hide 2)
                                                        (("2"
                                                          (hide 3)
                                                          (("2"
                                                            (decompose-equality)
                                                            (("2"
                                                              (replace
                                                               -1
                                                               :dir
                                                               rl)
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (replace
                                                                   -2
                                                                   :dir
                                                                   rl)
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (replace
                                                                       -3
                                                                       :dir
                                                                       rl)
                                                                      (("2"
                                                                        (assert)
                                                                        (("2"
                                                                          (lift-if)
                                                                          (("2"
                                                                            (ground)
                                                                            (("2"
                                                                              (hide
                                                                               -1)
                                                                              (("2"
                                                                                (hide
                                                                                 -1)
                                                                                (("2"
                                                                                  (hide
                                                                                   -1)
                                                                                  (("2"
                                                                                    (name
                                                                                     "DD"
                                                                                     "LAMBDA (i_1: nat):
                                       IF i_1 > x!2 OR i_1 > j THEN 0
                                       ELSE a(i_1) * (C(x!2, i_1) / C(m, i_1))
                                       ENDIF")
                                                                                    (("1"
                                                                                      (replace
                                                                                       -1)
                                                                                      (("1"
                                                                                        (name
                                                                                         "EE"
                                                                                         "LAMBDA (i_1: nat):
                                          IF i_1 > x!2 OR i_1 > j - 1 THEN 0
                                          ELSE a(i_1) * (C(x!2, i_1) / C(m, i_1))
                                          ENDIF")
                                                                                        (("1"
                                                                                          (replace
                                                                                           -1)
                                                                                          (("1"
                                                                                            (name
                                                                                             "FF"
                                                                                             "LAMBDA (i_1: nat):
                                             IF i_1 > x!2 OR i_1 > j THEN 0
                                             ELSE aa(i_1) * (C(x!2, i_1) / C(m, i_1))
                                             ENDIF")
                                                                                            (("1"
                                                                                              (replace
                                                                                               -1)
                                                                                              (("1"
                                                                                                (case
                                                                                                 "DD = (LAMBDA (i:nat): EE(i)+FF(i))")
                                                                                                (("1"
                                                                                                  (lemma
                                                                                                   "sigma_sum")
                                                                                                  (("1"
                                                                                                    (inst
                                                                                                     -
                                                                                                     "EE"
                                                                                                     "FF"
                                                                                                     "x!2"
                                                                                                     "0")
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil)
                                                                                                 ("2"
                                                                                                  (hide
                                                                                                   3)
                                                                                                  (("2"
                                                                                                    (decompose-equality)
                                                                                                    (("2"
                                                                                                      (replace
                                                                                                       -1
                                                                                                       :dir
                                                                                                       rl)
                                                                                                      (("2"
                                                                                                        (hide
                                                                                                         -1)
                                                                                                        (("2"
                                                                                                          (replace
                                                                                                           -1
                                                                                                           :dir
                                                                                                           rl)
                                                                                                          (("2"
                                                                                                            (hide
                                                                                                             -1)
                                                                                                            (("2"
                                                                                                              (replace
                                                                                                               -1
                                                                                                               :dir
                                                                                                               rl)
                                                                                                              (("2"
                                                                                                                (hide
                                                                                                                 -1)
                                                                                                                (("2"
                                                                                                                  (assert)
                                                                                                                  (("2"
                                                                                                                    (lift-if)
                                                                                                                    (("2"
                                                                                                                      (lift-if)
                                                                                                                      (("2"
                                                                                                                        (assert)
                                                                                                                        (("2"
                                                                                                                          (ground)
                                                                                                                          (("2"
                                                                                                                            (lift-if)
                                                                                                                            (("2"
                                                                                                                              (assert)
                                                                                                                              (("2"
                                                                                                                                (ground)
                                                                                                                                (("1"
                                                                                                                                  (replace
                                                                                                                                   -3
                                                                                                                                   :dir
                                                                                                                                   rl)
                                                                                                                                  (("1"
                                                                                                                                    (assert)
                                                                                                                                    nil
                                                                                                                                    nil))
                                                                                                                                  nil)
                                                                                                                                 ("2"
                                                                                                                                  (replace
                                                                                                                                   -2
                                                                                                                                   :dir
                                                                                                                                   rl)
                                                                                                                                  (("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"
                                                                                          (skosimp*)
                                                                                          (("2"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil))
                                                                                          nil)
                                                                                         ("3"
                                                                                          (skosimp*)
                                                                                          (("3"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (skosimp*)
                                                                                      (("2"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil)
                                                                                     ("3"
                                                                                      (skosimp*)
                                                                                      (("3"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (skosimp*)
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil)
                                                   ("3"
                                                    (skosimp*)
                                                    (("3"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (skosimp*)
                                            (("2" (assertnil nil))
                                            nil)
                                           ("3"
                                            (skosimp*)
                                            (("3" (assertnil nil))
                                            nil)
                                           ("4"
                                            (skosimp*)
                                            (("4" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (decompose-equality)
                                (("2"
                                  (expand "+" 1)
                                  (("2"
                                    (expand "polynomial" 1)
                                    (("2"
                                      (expand "sigma" 1 1)
                                      (("2"
                                        (lemma "sigma_split")
                                        (("2"
                                          (inst
                                           -
                                           "LAMBDA (i: nat): aa(i) * (IF i = 0 THEN 1 ELSE x!1 ^ i ENDIF)"
                                           "j"
                                           "0"
                                           "j-1")
                                          (("2"
                                            (assert)
                                            (("2"
                                              (replace -1)
                                              (("2"
                                                (hide -1)
                                                (("2"
                                                  (expand "sigma" 1 2)
                                                  (("2"
                                                    (expand
                                                     "sigma"
                                                     1
                                                     2)
                                                    (("2"
                                                      (lemma
                                                       "sigma_restrict_eq")
                                                      (("2"
                                                        (inst
                                                         -
                                                         "LAMBDA (i: nat): aa(i) * (IF i = 0 THEN 1 ELSE x!1 ^ i ENDIF)"
                                                         "LAMBDA (i: nat): 0"
                                                         "j-1"
                                                         "0")
                                                        (("2"
                                                          (lemma
                                                           "sigma_zero")
                                                          (("2"
                                                            (inst
                                                             -
                                                             "j-1"
                                                             "0")
                                                            (("2"
                                                              (assert)
                                                              (("2"
                                                                (replace
                                                                 -3
                                                                 :dir
                                                                 rl)
                                                                (("2"
                                                                  (assert)
                                                                  (("2"
                                                                    (decompose-equality)
                                                                    (("2"
                                                                      (expand
                                                                       "restrict")
                                                                      (("2"
                                                                        (lift-if)
                                                                        (("2"
                                                                          (ground)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (assertnil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((Bernstein_polynomial const-decl "Bernstein_Polynomial"
     bernstein_polynomials nil)
    (Bern_poly const-decl "[real -> real]" bernstein_polynomials nil)
    (Bernstein_Polynomial type-eq-decl nil bernstein_polynomials nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (polynomial const-decl "[real -> real]" polynomials nil)
    (sequence type-eq-decl nil sequences nil)
    (= const-decl "[T, T -> boolean]" equalities 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)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (NAT_induction formula-decl nil naturalnumbers nil)
    (sigma def-decl "real" sigma nil)
    (Bern const-decl "real" bernstein_polynomials nil)
    (above nonempty-type-eq-decl nil integers nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (C const-decl "posnat" binomial nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/= const-decl "boolean" notequal nil)
    (T_high type-eq-decl nil sigma nil)
    (T_low type-eq-decl nil sigma nil) (<= const-decl "bool" reals nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (> const-decl "bool" reals nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (sigma_scal formula-decl nil sigma nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (m skolem-const-decl "nat" bernstein_polynomials nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (posrat_div_posrat_is_posrat application-judgement "posrat"
     rationals nil)
    (Bernstein_partition_of_unity formula-decl nil
     bernstein_polynomials 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)
    (x!2 skolem-const-decl "nat" bernstein_polynomials nil)
    (sigma_restrict_eq formula-decl nil sigma nil)
    (both_sides_times1_imp formula-decl nil extra_real_props nil)
    (sigma_nnreal application-judgement "nnreal" sigma_nat nil)
    (sigma_nat application-judgement "nat" sigma_nat nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (factorial_0 formula-decl nil factorial "ints/")
    (sigma_zero formula-decl nil sigma nil)
    (restrict const-decl "[T -> real]" sigma nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (sigma_split formula-decl nil sigma nil)
    (sigma_0_neg formula-decl nil sigma_nat nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (+ const-decl "[T -> real]" real_fun_ops nil)
    (sigma_sum formula-decl nil sigma nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (even_plus_even_is_even application-judgement "even_int" integers
     nil)
    (< const-decl "bool" reals nil)
    (x!2 skolem-const-decl "nat" bernstein_polynomials nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (Bernstein_conversion_2 formula-decl nil bernstein_polynomials nil)
    (^ const-decl "real" exponentiation nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (j skolem-const-decl "nat" bernstein_polynomials nil)
    (pred type-eq-decl nil defined_types nil))
   shostak))
 (Bern_poly_inverse_def 0
  (Bern_poly_inverse_def-1 nil 3479635199
   ("" (skeep)
    (("" (decompose-equality)
      (("" (expand "polynomial")
        ((""
          (case "NOT (LAMBDA (i: nat):
                            Bern_poly_inverse(b)(i) *
                             (IF i = 0 THEN 1 ELSE x!1 ^ i ENDIF)) = (LAMBDA (i: nat):
                            Bern_poly_inverse(b)(i) * x!1^i)")
          (("1" (hide 2)
            (("1" (decompose-equality)
              (("1" (lift-if)
                (("1" (ground)
                  (("1" (replace -1)
                    (("1" (expand "^")
                      (("1" (expand "expt") (("1" (propax) nil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (replace -1)
            (("2" (hide -1)
              (("2" (expand "Bern_poly")
                (("2" (lemma "Bern_Polynomial")
                  (("2" (expand "polynomial")
                    (("2"
                      (case "NOT (LAMBDA (i: nat):
                                 IF i > b`index THEN 0
                                 ELSE b`bern_seq(i) * Bern(i, b`index)(x!1)
                                 ENDIF) =
                               (LAMBDA (i: nat):
                                 sigma(i,b`index,(LAMBDA (j:nat): IF j < i OR j > b`index OR i>b`index THEN 0 ELSE b`bern_seq(i)*(-1)^(j-i)*(C(b`index,j)*C(j,i))*x!1^j ENDIF)))")
                      (("1" (hide 2)
                        (("1" (decompose-equality)
                          (("1" (lift-if)
                            (("1" (ground)
                              (("1"
                                (lemma "sigma_zero")
                                (("1"
                                  (inst?)
                                  (("1" (assertnil nil))
                                  nil))
                                nil)
                               ("2"
                                (assert)
                                (("2"
                                  (inst - "x!2" "b`index")
                                  (("2"
                                    (replace -1)
                                    (("2"
                                      (hide -1)
                                      (("2"
                                        (assert)
                                        (("2"
                                          (name
                                           "AA"
                                           "LAMBDA (i_1: nat):
                              IF i_1 < x!2 OR i_1 > b`index THEN 0
                              ELSE C(i_1, x!2) * C(b`index, i_1) * (-1) ^ (i_1 - x!2)
                              ENDIF
                               * (IF i_1 = 0 THEN 1 ELSE x!1 ^ i_1 ENDIF)")
                                          (("1"
                                            (name
                                             "BB"
                                             "LAMBDA (j: nat):
                                IF j < x!2 OR j > b`index THEN 0
                                ELSE b`bern_seq(x!2) * (-1) ^ (j - x!2) * x!1 ^ j *
                                      (C(b`index, j) * C(j, x!2))
                                ENDIF")
                                            (("1"
                                              (replace -1)
                                              (("1"
                                                (replace -2)
                                                (("1"
                                                  (lemma "sigma_split")
                                                  (("1"
                                                    (inst
                                                     -
                                                     "AA"
                                                     "b`index"
                                                     "0"
                                                     "x!2-1")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (replace -1)
                                                        (("1"
                                                          (hide -1)
                                                          (("1"
                                                            (case
                                                             "sigma(0,x!2-1,AA) = 0")
                                                            (("1"
                                                              (replace
                                                               -1)
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (hide
                                                                   -1)
                                                                  (("1"
                                                                    (rewrite
                                                                     "sigma_scal"
                                                                     :dir
                                                                     rl)
                                                                    (("1"
                                                                      (lemma
                                                                       "sigma_restrict_eq")
                                                                      (("1"
                                                                        (inst?)
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (hide
                                                                             3)
                                                                            (("1"
                                                                              (decompose-equality)
                                                                              (("1"
                                                                                (expand
                                                                                 "restrict")
                                                                                (("1"
                                                                                  (lift-if)
                                                                                  (("1"
                                                                                    (ground)
                                                                                    (("1"
                                                                                      (replace
                                                                                       -1
                                                                                       :dir
                                                                                       rl)
                                                                                      (("1"
                                                                                        (replace
                                                                                         -2
                                                                                         :dir
                                                                                         rl)
                                                                                        (("1"
                                                                                          (assert)
                                                                                          (("1"
                                                                                            (case
                                                                                             "IF x!3 = 0 THEN 1 ELSE x!1 ^ x!3 ENDIF = x!1^x!3")
                                                                                            (("1"
                                                                                              (assert)
                                                                                              (("1"
                                                                                                (replace
                                                                                                 -1)
                                                                                                (("1"
                                                                                                  (assert)
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil)
                                                                                             ("2"
                                                                                              (hide
                                                                                               4)
                                                                                              (("2"
                                                                                                (lift-if)
                                                                                                (("2"
                                                                                                  (ground)
                                                                                                  (("2"
                                                                                                    (replace
                                                                                                     -1)
                                                                                                    (("2"
                                                                                                      (expand
                                                                                                       "^")
                                                                                                      (("2"
                                                                                                        (expand
                                                                                                         "expt")
                                                                                                        (("2"
                                                                                                          (propax)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (lemma
                                                               "sigma_zero")
                                                              (("2"
                                                                (inst
                                                                 -
                                                                 "x!2-1"
                                                                 "0")
                                                                (("2"
                                                                  (lemma
                                                                   "sigma_restrict_eq")
                                                                  (("2"
                                                                    (inst
                                                                     -
                                                                     "AA"
                                                                     "LAMBDA (i:nat): 0"
                                                                     "x!2-1"
                                                                     "0")
                                                                    (("2"
                                                                      (assert)
                                                                      (("2"
                                                                        (decompose-equality)
                                                                        (("2"
                                                                          (expand
                                                                           "restrict")
                                                                          (("2"
                                                                            (lift-if)
                                                                            (("2"
                                                                              (ground)
                                                                              (("2"
                                                                                (replace
                                                                                 -3
                                                                                 2
                                                                                 :dir
                                                                                 rl)
                                                                                (("2"
                                                                                  (assert)
                                                                                  (("2"
                                                                                    (lift-if)
                                                                                    (("2"
                                                                                      (ground)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (skosimp*)
                                            (("2" (assertnil nil))
                                            nil)
                                           ("3"
                                            (skosimp*)
                                            (("3" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (skosimp*) (("2" (assertnil nil))
                            nil)
                           ("3" (skosimp*) (("3" (assertnil nil))
                            nil)
                           ("4" (skosimp*) (("4" (assertnil nil))
                            nil)
                           ("5" (skosimp*) (("5" (assertnil nil))
                            nil)
                           ("6" (skosimp*) (("6" (assertnil nil))
                            nil))
                          nil))
                        nil)
                       ("2" (replace -1)
                        (("2" (hide -1)
                          (("2"
                            (name "F"
                                  "(LAMBDA (i,j:nat): IF j < i OR j > b`index OR i > b`index THEN 0
                         ELSE b`bern_seq(i) * (-1) ^ (j - i) *
                               (C(b`index, j) * C(j, i))
                               * x!1 ^ j
                         ENDIF)")
                            (("2" (lemma "sigma_swap_triangle")
                              (("2"
                                (inst - "F" "b`index" "b`index" "0")
                                (("2"
                                  (assert)
                                  (("2"
                                    (case
                                     "(LAMBDA (i: nat):
                sigma(i, b`index,
                      (LAMBDA (j: nat):
                         IF j < i OR j > b`index OR i > b`index THEN 0
                         ELSE b`bern_seq(i) * C(j, i) * C(b`index, j) *
                               (-1) ^ (j - i)
                               * x!1 ^ j
                         ENDIF))) = (LAMBDA (i: nat): sigma(i, b`index, LAMBDA (j: nat): F(i, j)))")
                                    (("1"
                                      (replace -1)
                                      (("1"
                                        (hide -1)
                                        (("1"
                                          (replace -1)
                                          (("1"
                                            (lemma "sigma_restrict_eq")
                                            (("1"
                                              (inst
                                               -
                                               "(LAMBDA (i: nat): Bern_poly_inverse(b)(i) * x!1 ^ i)"
                                               "(LAMBDA (j: nat): sigma(0, j, LAMBDA (i: nat): F(i, j)))"
                                               "b`index"
                                               "0")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (hide 2)
                                                  (("1"
                                                    (decompose-equality)
                                                    (("1"
                                                      (expand
                                                       "restrict")
                                                      (("1"
                                                        (lift-if)
                                                        (("1"
                                                          (ground)
                                                          (("1"
                                                            (expand
                                                             "Bern_poly_inverse")
                                                            (("1"
                                                              (name
                                                               "CC"
                                                               "LAMBDA (i: nat):
              IF i > x!2 THEN 0
              ELSE b`bern_seq(i) * C(b`index, x!2) * C(x!2, i) *
                    (-1) ^ (x!2 - i)
              ENDIF")
                                                              (("1"
                                                                (replace
                                                                 -1)
                                                                (("1"
                                                                  (lemma
                                                                   "sigma_scal")
                                                                  (("1"
                                                                    (inst
                                                                     -
                                                                     "CC"
                                                                     "x!1^x!2"
                                                                     "x!2"
                                                                     "0")
                                                                    (("1"
                                                                      (replace
                                                                       -1
                                                                       :dir
                                                                       rl)
                                                                      (("1"
                                                                        (hide
                                                                         -1)
                                                                        (("1"
                                                                          (lemma
                                                                           "sigma_restrict_eq")
                                                                          (("1"
                                                                            (inst?)
                                                                            (("1"
                                                                              (assert)
                                                                              (("1"
                                                                                (hide
                                                                                 3)
                                                                                (("1"
                                                                                  (decompose-equality)
                                                                                  (("1"
                                                                                    (expand
                                                                                     "restrict")
                                                                                    (("1"
                                                                                      (lift-if)
                                                                                      (("1"
                                                                                        (ground)
                                                                                        (("1"
                                                                                          (expand
                                                                                           "CC"
                                                                                           +)
                                                                                          (("1"
                                                                                            (expand
                                                                                             "F"
                                                                                             +)
                                                                                            (("1"
                                                                                              (assert)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (skosimp*)
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil)
                                                               ("3"
                                                                (skosimp*)
                                                                (("3"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (assert)
                                      (("2"
                                        (hide 2)
                                        (("2"
                                          (decompose-equality)
                                          (("1"
                                            (lemma "sigma_eq")
                                            (("1"
                                              (inst
                                               -
                                               "LAMBDA (j: nat):
              IF j < x!2 OR j > b`index OR x!2 > b`index THEN 0
              ELSE b`bern_seq(x!2) * C(j, x!2) * C(b`index, j) *
                    (-1) ^ (j - x!2)
                    * x!1 ^ j
              ENDIF"
                                               "LAMBDA (j: nat): F(x!2, j)"
                                               "b`index"
                                               "x!2")
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (hide 2)
                                                  (("1"
                                                    (skosimp*)
                                                    (("1"
                                                      (expand "F" +)
                                                      (("1"
                                                        (propax)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (skosimp*)
                                                (("2"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil)
                                               ("3"
                                                (skosimp*)
                                                (("3"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil)
                                               ("4"
                                                (skosimp*)
                                                (("4"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (skosimp*)
                                            (("2" (assertnil nil))
                                            nil)
                                           ("3"
                                            (skosimp*)
                                            (("3" (assertnil nil))
                                            nil)
                                           ("4"
                                            (skosimp*)
                                            (("4" (assertnil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("3" (skosimp*) (("3" (assertnil nil)) nil)
                       ("4" (skosimp*) (("4" (assertnil nil)) nil)
                       ("5" (skosimp*) (("5" (assertnil nil)) nil)
                       ("6" (skosimp*) (("6" (assertnil nil)) nil)
                       ("7" (skosimp*) (("7" (assertnil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    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)
    (sequence type-eq-decl nil sequences nil)
    (polynomial const-decl "[real -> real]" polynomials nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (Bernstein_Polynomial type-eq-decl nil bernstein_polynomials nil)
    (Bern_poly_inverse const-decl "sequence[real]"
     bernstein_polynomials nil)
    (Bern_poly const-decl "[real -> real]" bernstein_polynomials 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)
    (^ const-decl "real" exponentiation nil)
    (/= const-decl "boolean" notequal nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (expt def-decl "real" exponentiation nil)
    (Bern_Polynomial formula-decl nil bernstein_polynomials nil)
    (C const-decl "posnat" binomial nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (< const-decl "bool" reals nil) (sigma def-decl "real" sigma nil)
    (T_high type-eq-decl nil sigma nil)
    (T_low type-eq-decl nil sigma nil) (<= const-decl "bool" reals nil)
    (Bern const-decl "real" bernstein_polynomials nil)
    (above nonempty-type-eq-decl nil integers nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (> const-decl "bool" reals nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (b skolem-const-decl "Bernstein_Polynomial" bernstein_polynomials
     nil)
    (sigma_nnreal application-judgement "nnreal" sigma_nat nil)
    (sigma_nat application-judgement "nat" sigma_nat nil)
    (sigma_zero formula-decl nil sigma nil)
    (nzrat_times_nzrat_is_nzrat application-judgement "nzrat" rationals
     nil)
    (rat_exp application-judgement "rat" exponentiation nil)
    (nzreal_exp application-judgement "nzreal" exponentiation nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (sigma_split formula-decl nil sigma nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (sigma_restrict_eq formula-decl nil sigma nil)
    (restrict const-decl "[T -> real]" sigma nil)
    (nzreal_expt application-judgement "nzreal" exponentiation nil)
    (int_expt application-judgement "int" exponentiation nil)
    (sigma_scal formula-decl nil sigma 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)
    (sigma_swap_triangle formula-decl nil sigma_swap nil)
    (x!2 skolem-const-decl "nat" bernstein_polynomials nil)
    (sigma_eq formula-decl nil sigma nil)
    (CC skolem-const-decl "[nat -> real]" bernstein_polynomials nil)
    (F skolem-const-decl "[[nat, nat] -> real]" bernstein_polynomials
     nil))
   shostak))
 (Bern_subdiv_left_TCC1 0
  (Bern_subdiv_left_TCC1-1 nil 3485777030 ("" (subtype-tcc) nil nil)
   nil nil))
 (Bern_subdiv_left_TCC2 0
  (Bern_subdiv_left_TCC2-1 nil 3485777030 ("" (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)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (Bernstein_Polynomial type-eq-decl nil bernstein_polynomials nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (Bern_subdiv_left_TCC3 0
  (Bern_subdiv_left_TCC3-1 nil 3485777030 ("" (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)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (Bernstein_Polynomial type-eq-decl nil bernstein_polynomials nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (Bern_subdiv_right_TCC1 0
  (Bern_subdiv_right_TCC1-1 nil 3485768080 ("" (subtype-tcc) nil nil)
   nil nil))
 (Bern_subdiv_right_TCC2 0
  (Bern_subdiv_right_TCC2-1 nil 3485768080 ("" (subtype-tcc) nil nil)
   nil nil))
 (Bern_subdiv_right_TCC3 0
  (Bern_subdiv_right_TCC3-1 nil 3485768080 ("" (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)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (Bernstein_Polynomial type-eq-decl nil bernstein_polynomials nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (Bern_subdiv_right_TCC4 0
  (Bern_subdiv_right_TCC4-1 nil 3485777030 ("" (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)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (upto nonempty-type-eq-decl nil naturalnumbers nil)
    (Bernstein_Polynomial type-eq-decl nil bernstein_polynomials nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (Bern_subdiv_left_id 0
  (Bern_subdiv_left_id-2 nil 3485777078
   ("" (skeep)
    ((""
      (case "FORALL (xx :real): Bern_poly(Bern_subdiv_left(b))(xx) =
                                   (Bern_poly(b) o (LAMBDA (x: real): (1 / 2) * x))(xx)")
      (("1" (decompose-equality 1) nil nil)
       ("2" (hide 2)
        (("2" (skeep 1)
          (("2" (name "aa" "Bern_poly_inverse(b)")
            (("2" (lemma "Bern_poly_inverse_def")
              (("2" (inst - "b")
                (("2" (replace -2)
                  (("2" (replace -1 :dir rl)
                    (("2" (expand "o")
                      (("2" (name "nn" "b`index")
                        (("2" (replace -1)
                          (("2"
                            (name "az"
                                  "(LAMBDA (i:nat): (1/2^i)*aa(i))")
                            (("2"
                              (case "NOT polynomial(az,nn)(xx) = polynomial(aa,nn)((1/2)*xx)")
                              (("1"
                                (hide 2)
                                (("1"
                                  (expand "polynomial" +)
                                  (("1"
                                    (lemma "sigma_restrict_eq")
                                    (("1"
                                      (inst?)
                                      (("1"
                                        (assert)
                                        (("1"
                                          (hide 2)
                                          (("1"
                                            (decompose-equality 1)
                                            (("1"
                                              (expand "restrict")
                                              (("1"
                                                (lift-if)
                                                (("1"
                                                  (ground)
                                                  (("1"
                                                    (replace -1)
                                                    (("1"
                                                      (expand "az" +)
                                                      (("1"
                                                        (expand "^" +)
                                                        (("1"
                                                          (expand
                                                           "expt"
                                                           +)
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (lemma "mult_expt")
                                                    (("2"
                                                      (inst
                                                       -
                                                       "x!1"
                                                       "1/2"
                                                       "xx")
                                                      (("1"
                                                        (replace -1)
                                                        (("1"
                                                          (hide -1)
                                                          (("1"
                                                            (expand
                                                             "az"
                                                             +)
                                                            (("1"
                                                              (lemma
                                                               "div_expt")
                                                              (("1"
                                                                (inst
                                                                 -
                                                                 "x!1"
                                                                 "1"
                                                                 "2")
                                                                (("1"
                                                                  (replace
                                                                   -1)
                                                                  (("1"
                                                                    (hide
                                                                     -1)
                                                                    (("1"
                                                                      (case
                                                                       "1^x!1 = 1")
                                                                      (("1"
                                                                        (assert)
                                                                        nil
                                                                        nil)
                                                                       ("2"
                                                                        (case
                                                                         "FORALL (jjj:nat): 1^jjj = 1")
                                                                        (("1"
                                                                          (inst
                                                                           -
                                                                           "x!1")
                                                                          nil
                                                                          nil)
                                                                         ("2"
                                                                          (induct
                                                                           "jjj")
                                                                          (("1"
                                                                            (expand
                                                                             "^"
                                                                             1)
                                                                            (("1"
                                                                              (expand
                                                                               "expt"
                                                                               1)
                                                                              (("1"
                                                                                (propax)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (skeep
                                                                             1)
                                                                            (("2"
                                                                              (expand
                                                                               "^")
                                                                              (("2"
                                                                                (expand
                                                                                 "expt"
                                                                                 1)
                                                                                (("2"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (flatten)
                                                        (("2"
                                                          (replace -1)
                                                          (("2"
                                                            (expand
                                                             "^"
                                                             +)
                                                            (("2"
                                                              (expand
                                                               "expt"
                                                               +)
                                                              (("2"
                                                                (propax)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (replace -1 :dir rl)
                                (("2"
                                  (hide -1)
                                  (("2"
                                    (lemma "Bernstein_equivalence")
                                    (("2"
                                      (inst - "az" "nn" "nn")
                                      (("2"
                                        (assert)
                                        (("2"
                                          (replace -1)
                                          (("2"
                                            (hide -1)
                                            (("2"
                                              (expand
                                               "Bernstein_polynomial")
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (expand "az" 1)
                                                  (("2"
                                                    (expand "aa" 1)
                                                    (("2"
                                                      (expand
                                                       "Bern_poly_inverse"
                                                       1)
                                                      (("2"
                                                        (case
                                                         "Bern_subdiv_left(b) = (# index := nn,
                                                                bern_seq
                                                                  := LAMBDA (s: upto(nn)):
                                                                       sigma(0, s,
                                                                             LAMBDA (i: nat):
                                                                               IF i > s OR i > nn THEN 0
                                                                               ELSE sigma
                                                                                    (0,
                                                                                     i,
                                                                                     LAMBDA
                                                                                     (i_1: nat):
                                                                                     IF i_1 > i
                                                                                     THEN 0
                                                                                     ELSE b`bern_seq(i_1) * C(i, i_1)
                                                                                          *
                                                                                          C(b`index, i)
                                                                                          *
                                                                                          (-1) ^ (i - i_1)
                                                                                     ENDIF)
                                                                                    *
                                                                                    (1 / 2 ^ i)
                                                                                    *
                                                                                    (C(s, i) / C(nn, i))
                                                                               ENDIF) #)")
                                                        (("1"
                                                          (replaces -1)
                                                          nil
                                                          nil)
                                                         ("2"
                                                          (hide 2)
                                                          (("2"
                                                            (expand
                                                             "Bern_subdiv_left")
                                                            (("2"
                                                              (replace
                                                               -2)
                                                              (("2"
                                                                (decompose-equality
                                                                 1)
                                                                (("1"
                                                                  (lemma
                                                                   "sigma_swap_triangle")
                                                                  (("1"
                                                                    (name
                                                                     "F"
                                                                     "LAMBDA (j,i:nat): IF i > x!1 OR i > nn OR j > i THEN 0 ELSE (1/2^i)*(C(x!1, i) / C(nn, i))*b`bern_seq(j) * C(i, j) * C(nn, i) *
                                                                                              (-1) ^ (i - j) ENDIF")
                                                                    (("1"
                                                                      (case
                                                                       "NOT sigma(0, x!1,
                                                                                 LAMBDA (i: nat):
                                                                                   IF i > x!1 OR i > nn THEN 0
                                                                                   ELSE sigma(0, i,
                                                                                              LAMBDA (i_1: nat):
                                                                                                IF i_1 > i THEN 0
                                                                                                ELSE b`bern_seq(i_1) * C(i, i_1) * C(nn, i) *
                                                                                                      (-1) ^ (i - i_1)
                                                                                                ENDIF)
                                                                                         * (1 / 2 ^ i)
                                                                                         * (C(x!1, i) / C(nn, i))
                                                                                   ENDIF) = sigma(0,x!1,(LAMBDA (i:nat): sigma(0,i,(LAMBDA (j:nat):F(j,i)))))")
                                                                      (("1"
                                                                        (hide
                                                                         2)
                                                                        (("1"
                                                                          (lemma
                                                                           "sigma_restrict_eq")
                                                                          (("1"
                                                                            (inst?)
                                                                            (("1"
                                                                              (assert)
                                                                              (("1"
                                                                                (hide
                                                                                 2)
                                                                                (("1"
                                                                                  (decompose-equality
                                                                                   1)
                                                                                  (("1"
                                                                                    (expand
                                                                                     "restrict")
                                                                                    (("1"
                                                                                      (lift-if)
                                                                                      (("1"
                                                                                        (ground)
                                                                                        (("1"
                                                                                          (lemma
                                                                                           "sigma_scal")
                                                                                          (("1"
                                                                                            (inst
                                                                                             -
                                                                                             "LAMBDA (i_2: nat):
                                                                                      IF i_2 > x!2 THEN 0
                                                                                      ELSE b`bern_seq(i_2) * C(nn, x!2) * C(x!2, i_2) *
                                                                                            (-1) ^ (x!2 - i_2)
                                                                                      ENDIF"
                                                                                             "(1 / 2 ^ x!2)
                                                                               * (C(x!1, x!2) / C(nn, x!2))"
                                                                                             "x!2"
                                                                                             "0")
                                                                                            (("1"
                                                                                              (replace
                                                                                               -1
                                                                                               :dir
                                                                                               rl)
                                                                                              (("1"
                                                                                                (hide
                                                                                                 -1)
                                                                                                (("1"
                                                                                                  (lemma
                                                                                                   "sigma_restrict_eq")
                                                                                                  (("1"
                                                                                                    (inst?)
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      (("1"
                                                                                                        (hide
                                                                                                         3)
                                                                                                        (("1"
                                                                                                          (decompose-equality
                                                                                                           1)
                                                                                                          (("1"
                                                                                                            (expand
                                                                                                             "restrict")
                                                                                                            (("1"
                                                                                                              (lift-if)
                                                                                                              (("1"
                                                                                                                (ground)
                                                                                                                (("1"
                                                                                                                  (expand
                                                                                                                   "F"
                                                                                                                   +)
                                                                                                                  (("1"
                                                                                                                    (propax)
                                                                                                                    nil
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil)
                                                                                                           ("2"
                                                                                                            (skosimp*)
                                                                                                            (("2"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil)
                                                                                                           ("3"
                                                                                                            (skosimp*)
                                                                                                            (("3"
                                                                                                              (assert)
                                                                                                              nil
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("2"
                                                                                                      (skosimp*)
                                                                                                      (("2"
                                                                                                        (assert)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil)
                                                                                                     ("3"
                                                                                                      (skosimp*)
                                                                                                      (("3"
                                                                                                        (assert)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil)
                                                                                             ("2"
                                                                                              (skosimp*)
                                                                                              (("2"
                                                                                                (assert)
                                                                                                nil
                                                                                                nil))
                                                                                              nil)
                                                                                             ("3"
                                                                                              (skosimp*)
                                                                                              (("3"
                                                                                                (assert)
                                                                                                nil
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil)
                                                                                   ("2"
                                                                                    (skosimp*)
                                                                                    (("2"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil)
                                                                                   ("3"
                                                                                    (skosimp*)
                                                                                    (("3"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil)
                                                                                   ("4"
                                                                                    (skosimp*)
                                                                                    (("4"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil)
                                                                                   ("5"
                                                                                    (skosimp*)
                                                                                    (("5"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil)
                                                                                   ("6"
                                                                                    (skosimp*)
                                                                                    (("6"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (skosimp*)
                                                                              (("2"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil)
                                                                             ("3"
                                                                              (skosimp*)
                                                                              (("3"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil)
                                                                             ("4"
                                                                              (skosimp*)
                                                                              (("4"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil)
                                                                             ("5"
                                                                              (skosimp*)
                                                                              (("5"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil)
                                                                             ("6"
                                                                              (skosimp*)
                                                                              (("6"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (replace
                                                                         -1)
                                                                        (("2"
                                                                          (hide
                                                                           -1)
                                                                          (("2"
                                                                            (inst
                                                                             -
                                                                             "F"
                                                                             "x!1"
                                                                             "x!1"
                                                                             "0")
                                                                            (("2"
                                                                              (assert)
                                                                              (("2"
                                                                                (case
                                                                                 "(1 / 2 ^ x!1) *
                                                                                   sigma(0, x!1,
                                                                                         LAMBDA (j: nat):
                                                                                           IF j > x!1 THEN 0 ELSE C(x!1, j) * b`bern_seq(j) ENDIF) = sigma(0, x!1,
                                                                                        LAMBDA (j: nat): sigma(j, x!1, LAMBDA (i: nat): F(j, i)))")
                                                                                (("1"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil)
                                                                                 ("2"
                                                                                  (hide
                                                                                   2)
                                                                                  (("2"
                                                                                    (lemma
                                                                                     "sigma_scal")
                                                                                    (("2"
                                                                                      (inst
                                                                                       -
                                                                                       "LAMBDA (j: nat):
                                                                               IF j > x!1 THEN 0 ELSE C(x!1, j) * b`bern_seq(j) ENDIF"
                                                                                       "1/2^x!1"
                                                                                       "x!1"
                                                                                       "0")
                                                                                      (("1"
                                                                                        (replace
                                                                                         -1
                                                                                         :dir
                                                                                         rl)
                                                                                        (("1"
                                                                                          (hide
                                                                                           -1)
                                                                                          (("1"
                                                                                            (lemma
                                                                                             "sigma_restrict_eq")
                                                                                            (("1"
                                                                                              (inst?)
                                                                                              (("1"
                                                                                                (assert)
                                                                                                (("1"
                                                                                                  (hide
                                                                                                   2)
                                                                                                  (("1"
                                                                                                    (decompose-equality
                                                                                                     1)
                                                                                                    (("1"
                                                                                                      (expand
                                                                                                       "restrict"
                                                                                                       1)
                                                                                                      (("1"
                                                                                                        (lift-if)
                                                                                                        (("1"
                                                                                                          (ground)
                                                                                                          (("1"
                                                                                                            (expand
                                                                                                             "F"
                                                                                                             +)
                                                                                                            (("1"
                                                                                                              (hide
                                                                                                               -1)
                                                                                                              (("1"
                                                                                                                (hide
                                                                                                                 -1)
                                                                                                                (("1"
                                                                                                                  (case
                                                                                                                   "C(x!1, x!2) =
                                                                                                                   sigma(x!2, x!1,
                                                                                                                         LAMBDA (i: nat):
                                                                                                                           IF i > x!1 OR i > nn OR x!2 > i THEN 0
                                                                                                                           ELSE C(i, x!2) * C(nn, i) *
                                                                                                                                 (-1) ^ (i - x!2)
                                                                                                                                 * (1 / 2 ^ (i-x!1))
                                                                                                                                 * (C(x!1, i) / C(nn, i))
                                                                                                                           ENDIF)")
                                                                                                                  (("1"
                                                                                                                    (mult-by
                                                                                                                     -1
                                                                                                                     "1/2^x!1 * b`bern_seq(x!2)")
                                                                                                                    (("1"
                                                                                                                      (replace
                                                                                                                       -1)
                                                                                                                      (("1"
                                                                                                                        (hide
                                                                                                                         -1)
                                                                                                                        (("1"
                                                                                                                          (lemma
                                                                                                                           "sigma_scal")
                                                                                                                          (("1"
                                                                                                                            (inst
                                                                                                                             -
                                                                                                                             "LAMBDA (i: nat):
                                                                                                                      IF i > x!1 OR i > nn OR x!2 > i THEN 0
                                                                                                                      ELSE C(i, x!2) * C(nn, i) * (-1) ^ (i - x!2) *
                                                                                                                            (1 / 2 ^ (i - x!1))
                                                                                                                            * (C(x!1, i) / C(nn, i))
                                                                                                                      ENDIF"
                                                                                                                             "(1 / 2 ^ x!1 * b`bern_seq(x!2))"
                                                                                                                             "x!1"
                                                                                                                             "x!2")
                                                                                                                            (("1"
                                                                                                                              (replace
                                                                                                                               -1
                                                                                                                               :dir
                                                                                                                               rl)
                                                                                                                              (("1"
                                                                                                                                (hide
                                                                                                                                 -1)
                                                                                                                                (("1"
                                                                                                                                  (lemma
                                                                                                                                   "sigma_restrict_eq")
                                                                                                                                  (("1"
                                                                                                                                    (inst?)
                                                                                                                                    (("1"
                                                                                                                                      (assert)
                                                                                                                                      (("1"
                                                                                                                                        (hide
                                                                                                                                         3)
                                                                                                                                        (("1"
                                                                                                                                          (decompose-equality
                                                                                                                                           1)
                                                                                                                                          (("1"
                                                                                                                                            (expand
                                                                                                                                             "restrict")
                                                                                                                                            (("1"
                                                                                                                                              (lift-if)
                                                                                                                                              (("1"
                                                                                                                                                (ground)
                                                                                                                                                (("1"
                                                                                                                                                  (case
                                                                                                                                                   " (1 / 2 ^ (x!3 - x!1))
                                                                                                       * (1 / 2 ^ x!1) = 1/2^x!3")
                                                                                                                                                  (("1"
                                                                                                                                                    (replace
                                                                                                                                                     -1
                                                                                                                                                     :dir
                                                                                                                                                     rl)
                                                                                                                                                    (("1"
                                                                                                                                                      (assert)
                                                                                                                                                      nil
                                                                                                                                                      nil))
                                                                                                                                                    nil)
                                                                                                                                                   ("2"
                                                                                                                                                    (hide-all-but
                                                                                                                                                     (1
                                                                                                                                                      2
                                                                                                                                                      3))
                                                                                                                                                    (("2"
                                                                                                                                                      (case
                                                                                                                                                       "2^(x!3-x!1)*2^x!1 = 2^x!3")
                                                                                                                                                      (("1"
                                                                                                                                                        (assert)
                                                                                                                                                        nil
                                                                                                                                                        nil)
                                                                                                                                                       ("2"
                                                                                                                                                        (hide
                                                                                                                                                         2)
                                                                                                                                                        (("2"
                                                                                                                                                          (lemma
                                                                                                                                                           "expt_plus")
                                                                                                                                                          (("2"
                                                                                                                                                            (inst?)
                                                                                                                                                            (("2"
                                                                                                                                                              (assert)
                                                                                                                                                              nil
                                                                                                                                                              nil))
                                                                                                                                                            nil))
                                                                                                                                                          nil))
                                                                                                                                                        nil))
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil)
                                                                                                                                           ("2"
                                                                                                                                            (skosimp*)
                                                                                                                                            (("2"
                                                                                                                                              (assert)
                                                                                                                                              nil
                                                                                                                                              nil))
                                                                                                                                            nil)
                                                                                                                                           ("3"
                                                                                                                                            (skosimp*)
                                                                                                                                            (("3"
                                                                                                                                              (assert)
                                                                                                                                              nil
                                                                                                                                              nil))
                                                                                                                                            nil)
                                                                                                                                           ("4"
                                                                                                                                            (skosimp*)
                                                                                                                                            (("4"
                                                                                                                                              (assert)
                                                                                                                                              nil
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil)
                                                                                                                                     ("2"
                                                                                                                                      (skosimp*)
                                                                                                                                      (("2"
                                                                                                                                        (assert)
                                                                                                                                        nil
                                                                                                                                        nil))
                                                                                                                                      nil)
                                                                                                                                     ("3"
                                                                                                                                      (skosimp*)
                                                                                                                                      (("3"
                                                                                                                                        (assert)
                                                                                                                                        nil
                                                                                                                                        nil))
                                                                                                                                      nil)
                                                                                                                                     ("4"
                                                                                                                                      (skosimp*)
                                                                                                                                      (("4"
                                                                                                                                        (assert)
                                                                                                                                        nil
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil)
                                                                                                                             ("2"
                                                                                                                              (skosimp*)
                                                                                                                              (("2"
                                                                                                                                (assert)
                                                                                                                                nil
                                                                                                                                nil))
                                                                                                                              nil)
                                                                                                                             ("3"
                                                                                                                              (skosimp*)
                                                                                                                              (("3"
                                                                                                                                (assert)
                                                                                                                                nil
                                                                                                                                nil))
                                                                                                                              nil)
                                                                                                                             ("4"
                                                                                                                              (skosimp*)
                                                                                                                              (("4"
                                                                                                                                (assert)
                                                                                                                                nil
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil)
                                                                                                                     ("2"
                                                                                                                      (skosimp*)
                                                                                                                      (("2"
                                                                                                                        (assert)
                                                                                                                        nil
                                                                                                                        nil))
                                                                                                                      nil)
                                                                                                                     ("3"
                                                                                                                      (skosimp*)
                                                                                                                      (("3"
                                                                                                                        (assert)
                                                                                                                        nil
                                                                                                                        nil))
                                                                                                                      nil)
                                                                                                                     ("4"
                                                                                                                      (skosimp*)
                                                                                                                      (("4"
                                                                                                                        (assert)
                                                                                                                        nil
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil)
                                                                                                                   ("2"
                                                                                                                    (hide
                                                                                                                     3)
                                                                                                                    (("2"
                                                                                                                      (case
                                                                                                                       "C(x!1, x!2) =
                                                                                              sigma(x!2, x!1,
                                                                                                    LAMBDA (i: nat):
                                                                                                      IF i > x!1 OR i > nn OR x!2 > i THEN 0
                                                                                                      ELSE C(i, x!2)*C(x!1, i) * (-1) ^ (i - x!2) *
                                                                                                            (1 / 2 ^ (i - x!1))
                                                                                                      ENDIF)")
                                                                                                                      (("1"
                                                                                                                        (assert)
                                                                                                                        (("1"
                                                                                                                          (replace
                                                                                                                           -1
                                                                                                                           +)
                                                                                                                          (("1"
                                                                                                                            (lemma
                                                                                                                             "sigma_restrict_eq")
                                                                                                                            (("1"
                                                                                                                              (inst?)
                                                                                                                              (("1"
                                                                                                                                (assert)
                                                                                                                                (("1"
                                                                                                                                  (hide
                                                                                                                                   2)
                                                                                                                                  (("1"
                                                                                                                                    (decompose-equality
                                                                                                                                     1)
                                                                                                                                    (("1"
                                                                                                                                      (expand
                                                                                                                                       "restrict")
                                                                                                                                      (("1"
                                                                                                                                        (lift-if)
                                                                                                                                        (("1"
                                                                                                                                          (ground)
                                                                                                                                          nil
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil)
                                                                                                                                     ("2"
                                                                                                                                      (skosimp*)
                                                                                                                                      (("2"
                                                                                                                                        (assert)
                                                                                                                                        nil
                                                                                                                                        nil))
                                                                                                                                      nil)
                                                                                                                                     ("3"
                                                                                                                                      (skosimp*)
                                                                                                                                      (("3"
                                                                                                                                        (assert)
                                                                                                                                        nil
                                                                                                                                        nil))
                                                                                                                                      nil)
                                                                                                                                     ("4"
                                                                                                                                      (skosimp*)
                                                                                                                                      (("4"
                                                                                                                                        (assert)
                                                                                                                                        nil
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil)
                                                                                                                               ("2"
                                                                                                                                (skosimp*)
                                                                                                                                (("2"
                                                                                                                                  (assert)
                                                                                                                                  nil
                                                                                                                                  nil))
                                                                                                                                nil)
                                                                                                                               ("3"
--> --------------------

--> maximum size reached

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

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

¤ Diese beiden folgenden Angebotsgruppen bietet das Unternehmen1.447Angebot  (Wie Sie bei der Firma Beratungs- und Dienstleistungen beauftragen können 2026-04-26) ¤

*Eine klare Vorstellung vom Zielzustand






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